Aumente o desempenho de inferência para modelos Mixtral e Llama 2 com novos contêineres Amazon SageMaker | Amazon Web Services

Em janeiro, 2024, Amazon Sage Maker lançou uma nova versão (0.26.0) de contêineres de aprendizado profundo (DLCs) de inferência de modelo grande (LMI). Esta versão oferece suporte para novos modelos (incluindo Mixture of Experts), melhorias de desempenho e usabilidade em back-ends de inferência, bem como detalhes de nova geração para maior controle e explicabilidade de previsão (como motivo da conclusão da geração e probabilidades de log em nível de token).

Os DLCs LMI oferecem uma interface de baixo código que simplifica o uso de técnicas e hardware de otimização de inferência de última geração. LMI permite aplicar paralelismo tensorial; as mais recentes técnicas eficientes de atenção, processamento em lote, quantização e gerenciamento de memória; streaming de tokens; e muito mais, exigindo apenas o ID do modelo e parâmetros opcionais do modelo. Com DLCs LMI no SageMaker, você pode acelerar o tempo de obtenção de valor para seu inteligência artificial generativa (IA) aplicativos, descarregue o trabalho pesado relacionado à infraestrutura e otimize modelos de linguagem grandes (LLMs) para o hardware de sua escolha para obter o melhor desempenho em termos de preço da categoria.

Nesta postagem, exploramos os recursos mais recentes introduzidos nesta versão, examinamos benchmarks de desempenho e fornecemos um guia detalhado sobre a implantação de novos LLMs com DLCs LMI com alto desempenho.

Novos recursos com DLCs LMI

Nesta seção, discutimos novos recursos em back-ends LMI e detalhamos alguns outros que são específicos de back-end. Atualmente, o LMI oferece suporte aos seguintes back-ends:

• Biblioteca distribuída por LMI – Este é o framework AWS para executar inferência com LLMs, inspirado em OSS, para obter a melhor latência e precisão possíveis no resultado
• LMI vLLM – Esta é a implementação de back-end da AWS do sistema com eficiência de memória vLLM biblioteca de inferência
• Kit de ferramentas LMI TensorRT-LLM – Esta é a implementação de back-end da AWS de NVIDIA TensorRT-LLM, que cria mecanismos específicos de GPU para otimizar o desempenho em diferentes GPUs
• LMI DeepSpeed – Esta é a adaptação AWS de Velocidade Profunda, que adiciona lotes contínuos verdadeiros, quantização SmoothQuant e a capacidade de ajustar dinamicamente a memória durante a inferência
• LMI NeuronX – Você pode usar isso para implantação em AWS Inferencia2 e Treinamento AWSbaseadas em instâncias, apresentando lotes e acelerações verdadeiramente contínuos, com base no SDK do AWS Neuron

A tabela a seguir resume os recursos recém-adicionados, tanto comuns quanto específicos de back-end.

Novos modelos suportados

Novos modelos populares são suportados em back-ends, como Mistral-7B (todos os back-ends), Mixtral baseado em MoE (todos os back-ends, exceto Transformers-NeuronX) e Llama2-70B (Transformers-NeuronX).

Técnicas de extensão de janela de contexto

O dimensionamento de contexto baseado em Rotary Positional Embedding (RoPE) agora está disponível nos back-ends LMI-Dist, vLLM e TensorRT-LLM. O escalonamento RoPE permite a extensão do comprimento da sequência de um modelo durante a inferência para praticamente qualquer tamanho, sem a necessidade de ajuste fino.

A seguir estão duas considerações importantes ao usar RoPE:

• Perplexidade do modelo – À medida que o comprimento da sequência aumenta, então pode o modelo perplexidade. Este efeito pode ser parcialmente compensado através da realização de ajustes mínimos em sequências de entrada maiores do que aquelas usadas no treinamento original. Para uma compreensão aprofundada de como o RoPE afeta a qualidade do modelo, consulte Estendendo a corda.
• Desempenho de inferência – Comprimentos de sequência mais longos consumirão a memória de alta largura de banda (HBM) do acelerador maior. Esse aumento no uso de memória pode afetar negativamente o número de solicitações simultâneas que seu acelerador pode manipular.

Detalhes de geração adicionados

Agora você pode obter dois detalhes detalhados sobre os resultados da geração:

• razão_de_acabamento – Isso fornece o motivo da conclusão da geração, que pode atingir o comprimento máximo da geração, gerar um token de final de frase (EOS) ou gerar um token de parada definido pelo usuário. Ele é retornado com o último pedaço da sequência transmitida.
• log_probs – Isso retorna a probabilidade logarítmica atribuída pelo modelo para cada token no bloco de sequência transmitido. Você pode usá-los como uma estimativa aproximada da confiança do modelo, calculando a probabilidade conjunta de uma sequência como a soma dos log_probs dos tokens individuais, o que pode ser útil para pontuar e classificar os resultados do modelo. Esteja ciente de que as probabilidades do token LLM geralmente são excessivamente confiantes sem calibração.

Você pode ativar a saída dos resultados de geração adicionandodetails=True em sua carga de entrada ao LMI, deixando todos os outros parâmetros inalterados:

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

Parâmetros de configuração consolidados

Finalmente, os parâmetros de configuração da LMI também foram consolidados. Para obter mais informações sobre todos os parâmetros de configuração de implantação comuns e específicos de back-end, consulte Configurações de inferência de modelos grandes.

Back-end distribuído por LMI

No AWS re:Invent 2023, a LMI-Dist adicionou operações coletivas novas e otimizadas para acelerar a comunicação entre GPUs, resultando em menor latência e maior rendimento para modelos que são grandes demais para uma única GPU. Esses coletivos estão disponíveis exclusivamente para SageMaker, para instâncias p4d.

Enquanto a iteração anterior suportava apenas a fragmentação em todas as 8 GPUs, o LMI 0.26.0 introduz suporte para um grau paralelo de tensor de 4, em um padrão parcial de todos para todos. Isto pode ser combinado com Componentes de inferência do SageMaker, com o qual você pode configurar granularmente quantos aceleradores devem ser alocados para cada modelo implantado atrás de um endpoint. Juntos, esses recursos fornecem melhor controle sobre a utilização de recursos da instância subjacente, permitindo aumentar a multilocação do modelo hospedando diferentes modelos atrás de um endpoint ou ajustando a taxa de transferência agregada de sua implantação para corresponder ao seu modelo e às características de tráfego.

A figura a seguir compara tudo direto com tudo parcial.

Back-end TensorRT-LLM

O TensorRT-LLM da NVIDIA foi introduzido como parte da versão anterior do LMI DLC (0.25.0), permitindo desempenho de GPU de última geração e otimizações como SmoothQuant, FP8 e lote contínuo para LLMs ao usar GPUs NVIDIA.

O TensorRT-LLM exige que os modelos sejam compilados em mecanismos eficientes antes da implantação. O DLC LMI TensorRT-LLM pode lidar automaticamente com a compilação de uma lista de modelos suportados just-in-time (JIT), antes de iniciar o servidor e carregar o modelo para inferência em tempo real. A versão 0.26.0 do DLC aumenta a lista de modelos suportados para compilação JIT, introduzindo os modelos Baichuan, ChatGLM, GPT2, GPT-J, InternLM, Mistral, Mixtral, Qwen, SantaCoder e StarCoder.

A compilação JIT adiciona vários minutos de sobrecarga ao provisionamento de endpoint e ao tempo de dimensionamento, por isso é sempre recomendável compilar seu modelo com antecedência. Para obter um guia sobre como fazer isso e uma lista de modelos suportados, consulte Tutorial de compilação antecipada de modelos do TensorRT-LLM. Se o modelo selecionado ainda não for compatível, consulte Tutorial de compilação manual de modelos do TensorRT-LLM para compilar qualquer outro modelo compatível com TensorRT-LLM.

Além disso, o LMI agora expõe a quantização nativa do TensorRT-LLM SmootQuant, com parâmetros para controlar alfa e fator de escala por token ou canal. Para obter mais informações sobre as configurações relacionadas, consulte TensorRT-LLM.

back-end do vLLM

A versão atualizada do vLLM incluída no LMI DLC apresenta melhorias de desempenho de até 50% alimentadas pelo modo gráfico CUDA em vez do modo ansioso. Os gráficos CUDA aceleram as cargas de trabalho da GPU, iniciando várias operações da GPU de uma só vez, em vez de lançá-las individualmente, o que reduz as despesas gerais. Isto é particularmente eficaz para modelos pequenos ao usar paralelismo tensorial.

O desempenho adicional vem em troca do consumo adicional de memória da GPU. O modo gráfico CUDA agora é padrão para o back-end vLLM, portanto, se você estiver limitado à quantidade de memória GPU disponível, poderá definir option.enforce_eager=True para forçar o modo ansioso do PyTorch.

Back-end Transformers-NeuronX

A versão atualizada do NeuronX incluído no LMI NeuronX DLC agora suporta modelos que apresentam o mecanismo de atenção de consulta agrupada, como Mistral-7B e LLama2-70B. A atenção de consulta agrupada é uma otimização importante do mecanismo de atenção do transformador padrão, onde o modelo é treinado com menos cabeças de chave e valor do que cabeças de consulta. Isso reduz o tamanho do cache KV na memória da GPU, permitindo maior simultaneidade e melhorando o preço-desempenho.

A figura a seguir ilustra métodos de atenção multi-head, consulta agrupada e multi-consulta (fonte).

Diferentes estratégias de fragmentação de cache KV estão disponíveis para atender a diferentes tipos de cargas de trabalho. Para obter mais informações sobre estratégias de fragmentação, consulte Suporte para atenção de consulta agrupada (GQA). Você pode ativar a estratégia desejada (shard-over-heads, por exemplo) com o seguinte código:

option.group_query_attention=shard-over-heads

Além disso, a nova implementação do NeuronX DLC introduz uma API de cache para TransformerNeuronX que permite acesso ao cache KV. Ele permite inserir e remover linhas de cache KV de novas solicitações enquanto você realiza inferência em lote. Antes de introduzir esta API, o cache KV era recalculado para quaisquer solicitações recém-adicionadas. Em comparação com o LMI V7 (0.25.0), melhoramos a latência em mais de 33% com solicitações simultâneas e oferecemos suporte a uma taxa de transferência muito maior.

Selecionando o back-end certo

Para decidir qual back-end usar com base no modelo e na tarefa selecionados, use o fluxograma a seguir. Para guias de usuário de back-end individuais junto com modelos suportados, consulte Guias do usuário de back-end do LMI.

Implante Mixtral com LMI DLC com atributos adicionais

Vamos ver como você pode implantar o modelo Mixtral-8x7B com contêiner LMI 0.26.0 e gerar detalhes adicionais como log_prob e finish_reason como parte da saída. Também discutimos como você pode se beneficiar desses atributos adicionais por meio de um caso de uso de geração de conteúdo.

O caderno completo com instruções detalhadas está disponível no GitHub repo.

Começamos importando as bibliotecas e configurando o ambiente de sessão:

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

Você pode usar contêineres SageMaker LMI para hospedar modelos sem nenhum código de inferência adicional. Você pode configurar o servidor modelo por meio das variáveis ​​de ambiente ou de um serving.properties arquivo. Opcionalmente, você poderia ter um model.py arquivo para qualquer pré-processamento ou pós-processamento e um requirements.txt arquivo para quaisquer pacotes adicionais que precisem ser instalados.

Neste caso, usamos o serving.properties para configurar os parâmetros e personalizar o comportamento do contêiner LMI. Para mais detalhes, consulte o GitHub repo. O repositório explica detalhes dos vários parâmetros de configuração que você pode definir. Precisamos dos seguintes parâmetros principais:

• motor – Especifica o mecanismo de tempo de execução a ser usado pelo DJL. Isso orienta a fragmentação e a estratégia de carregamento do modelo nos aceleradores do modelo.
• opção.model_id – Especifica o Serviço de armazenamento simples da Amazon (Amazon S3) URI do modelo pré-treinado ou ID do modelo de um modelo pré-treinado hospedado em um repositório de modelo em Abraçando o rosto. Neste caso, fornecemos o ID do modelo Mixtral-8x7B.
• opção.tensor_parallel_degree – Define o número de dispositivos GPU nos quais o Accelerate precisa particionar o modelo. Este parâmetro também controla o número de trabalhadores por modelo que serão iniciados quando o serviço DJL for executado. Definimos esse valor para max (GPU máximo na máquina atual).
• opção.rolling_batch – Permite lotes contínuos para otimizar a utilização do acelerador e o rendimento geral. Para o contêiner TensorRT-LLM, usamos auto.
• opção.model_loading_timeout – Define o valor de tempo limite para download e carregamento do modelo para servir inferência.
• opção.max_rolling_batch – Define o tamanho máximo do lote contínuo, definindo quantas sequências podem ser processadas em paralelo a qualquer 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

Nós embalamos o serving.properties arquivo de configuração no formato tar.gz, para que atenda aos requisitos de hospedagem do SageMaker. Configuramos o contêiner DJL LMI com tensorrtllm como o mecanismo de back-end. Além disso, especificamos a versão mais recente do contêiner (0.26.0).

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

A seguir, carregamos o tarball local (contendo o serving.properties arquivo de configuração) para um prefixo S3. Usamos o URI da imagem para o contêiner DJL e o local do Amazon S3 para o qual o modelo que atende o tarball dos artefatos foi carregado, para criar o objeto de modelo do 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
)

Como parte do LMI 0.26.0, agora você pode usar dois detalhes adicionais detalhados sobre a saída gerada:

• log_probs – Esta é a probabilidade logarítmica atribuída pelo modelo para cada token no bloco de sequência transmitida. Você pode usá-los como uma estimativa aproximada da confiança do modelo, calculando a probabilidade conjunta de uma sequência como a soma das probabilidades logarítmicas dos tokens individuais, o que pode ser útil para pontuar e classificar os resultados do modelo. Esteja ciente de que as probabilidades do token LLM geralmente são excessivamente confiantes sem calibração.
• razão_de_acabamento – Este é o motivo da conclusão da geração, que pode atingir o comprimento máximo de geração, gerar um token EOS ou gerar um token de parada definido pelo usuário. Isso é retornado com o último pedaço da sequência transmitida.

Você pode habilitá-los passando "details"=True como parte de sua entrada para o modelo.

Vamos ver como você pode gerar esses detalhes. Usamos um exemplo de geração de conteúdo para entender sua aplicação.

Nós definimos um LineIterator classe auxiliar, que tem funções para buscar bytes preguiçosamente de um fluxo de resposta, armazená-los em buffer e dividir o buffer em linhas. A ideia é servir bytes do buffer enquanto busca mais bytes do fluxo de forma assíncrona.

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'])

Gere e use a probabilidade simbólica como um detalhe adicional

Considere um caso de uso em que estamos gerando conteúdo. Especificamente, temos a tarefa de escrever um breve parágrafo sobre os benefícios de praticar exercícios regularmente para um site focado no estilo de vida. Queremos gerar conteúdo e gerar alguma pontuação indicativa da confiança que o modelo tem no conteúdo gerado.

Invocamos o endpoint do modelo com nosso prompt e capturamos a resposta gerada. Montamos "details": True como um parâmetro de tempo de execução na entrada do modelo. Como o log de probabilidade é gerado para cada token de saída, anexamos as probabilidades de log individuais a uma lista. Também capturamos o texto completo gerado da resposta.

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']

Para calcular a pontuação de confiança geral, calculamos a média de todas as probabilidades do token individual e subsequentemente obtemos o valor exponencial entre 0 e 1. Esta é a nossa pontuação de confiança geral inferida para o texto gerado, que neste caso é um parágrafo sobre os benefícios de exercício regular.

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

Este foi um exemplo de como você pode gerar e usar log_prob, no contexto de um caso de uso de geração de conteúdo. Da mesma forma, você pode usar log_prob como medida de pontuação de confiança para casos de uso de classificação.

Alternativamente, você pode usá-lo para a sequência de saída geral ou pontuação em nível de frase para avaliar o efeito de parâmetros como temperatura na saída gerada.

Gere e use o motivo de término como um detalhe adicional

Vamos desenvolver o mesmo caso de uso, mas desta vez temos a tarefa de escrever um artigo mais longo. Além disso, queremos ter certeza de que a saída não será truncada devido a problemas de comprimento de geração (comprimento máximo do token) ou devido à ocorrência de tokens de parada.

Para conseguir isso, usamos o finish_reason atributo gerado na saída, monitore seu valor e continue gerando até que toda a saída seja gerada.

Definimos uma função de inferência que recebe uma entrada de carga útil e chama o endpoint SageMaker, transmite uma resposta e processa a resposta para extrair o texto gerado. A carga contém o texto do prompt como entradas e parâmetros como máximo de tokens e detalhes. A resposta é lida em um fluxo e processada linha por linha para extrair os tokens de texto gerados em uma lista. Extraímos detalhes como finish_reason. Chamamos a função de inferência em um loop (solicitações encadeadas) enquanto adicionamos mais contexto a cada vez e rastreamos o número de tokens gerados e o número de solicitações enviadas até que o modelo termine.

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

Como podemos ver, mesmo que o max_new_token for definido como 256, usaremos o atributo de detalhe finish_reason como parte da saída para encadear várias solicitações ao endpoint, até que toda a saída seja gerada.

Da mesma forma, com base no seu caso de uso, você pode usar stop_reason para detectar comprimento insuficiente de sequência de saída especificado para uma determinada tarefa ou conclusão não intencional devido a uma sequência de parada humana.

Conclusão

Nesta postagem, percorremos a versão v0.26.0 do contêiner AWS LMI. Destacamos as principais melhorias de desempenho, suporte a novos modelos e novos recursos de usabilidade. Com esses recursos, você pode equilibrar melhor as características de custo e desempenho e, ao mesmo tempo, fornecer uma melhor experiência aos usuários finais.

Para saber mais sobre os recursos do LMI DLC, consulte Paralelismo de modelo e inferência de modelo grande. Estamos entusiasmados em ver como você usará esses novos recursos do SageMaker.

Sobre os autores

João moura é arquiteto de soluções especialista sênior em IA/ML na AWS. João ajuda os clientes da AWS – desde pequenas startups até grandes empresas – a treinar e implantar grandes modelos com eficiência e a construir plataformas de ML de forma mais ampla na AWS.

Rahul Sharma é arquiteto de soluções sênior na AWS, ajudando os clientes da AWS a projetar e construir soluções de IA/ML. Antes de ingressar na AWS, Rahul passou vários anos no setor financeiro e de seguros, ajudando clientes a criar plataformas analíticas e de dados.

Qinglan é engenheiro de desenvolvimento de software na AWS. Ele vem trabalhando em vários produtos desafiadores na Amazon, incluindo soluções de inferência de ML de alto desempenho e sistema de registro de alto desempenho. A equipe de Qing lançou com sucesso o primeiro modelo Billion-parameter no Amazon Advertising com latência muito baixa necessária. Qing possui profundo conhecimento sobre otimização de infraestrutura e aceleração de Deep Learning.

Jian Sheng é engenheiro de desenvolvimento de software na Amazon Web Services e trabalhou em vários aspectos importantes de sistemas de aprendizado de máquina. Ele tem sido um contribuidor importante para o serviço SageMaker Neo, com foco na compilação de aprendizagem profunda e na otimização do tempo de execução da estrutura. Recentemente, ele direcionou seus esforços e contribuiu para otimizar o sistema de aprendizado de máquina para inferência de modelos grandes.

Tyler Osterberg é engenheiro de desenvolvimento de software na AWS. Ele é especialista na criação de experiências de inferência de aprendizado de máquina de alto desempenho no SageMaker. Recentemente, seu foco tem sido otimizar o desempenho dos Inferentia Deep Learning Containers na plataforma SageMaker. Tyler se destaca na implementação de soluções de hospedagem de alto desempenho para grandes modelos de linguagem e no aprimoramento da experiência do usuário usando tecnologia de ponta.

Rupinder Grewal é arquiteto de soluções especialista sênior em IA/ML da AWS. Atualmente, ele se concentra no fornecimento de modelos e MLOps no Amazon SageMaker. Antes dessa função, ele trabalhou como engenheiro de aprendizado de máquina construindo e hospedando modelos. Fora do trabalho, ele gosta de jogar tênis e andar de bicicleta em trilhas de montanha.

Dhawal Patel é Arquiteto Principal de Machine Learning na AWS. Ele trabalhou com organizações que vão desde grandes empresas até startups de médio porte em problemas relacionados à computação distribuída e Inteligência Artificial. Ele se concentra em aprendizado profundo, incluindo domínios de PNL e Visão Computacional. Ele ajuda os clientes a obter inferência de modelo de alto desempenho no SageMaker.

Raghu Ramesha é arquiteto sênior de soluções de ML da equipe do Amazon SageMaker Service. Ele se concentra em ajudar os clientes a criar, implantar e migrar cargas de trabalho de produção de ML para o SageMaker em escala. Ele é especialista em domínios de aprendizado de máquina, IA e visão computacional, e possui mestrado em Ciência da Computação pela UT Dallas. Nas horas vagas gosta de viajar e fotografar.

• Conteúdo com tecnologia de SEO e distribuição de relações públicas. Seja amplificado hoje.
• PlatoData.Network Gerativa Vertical Ai. Capacite-se. Acesse aqui.
• PlatoAiStream. Inteligência Web3. Conhecimento Amplificado. Acesse aqui.
• PlatãoESG. Carbono Tecnologia Limpa, Energia, Ambiente, Solar, Gestão de resíduos. Acesse aqui.
• PlatoHealth. Inteligência em Biotecnologia e Ensaios Clínicos. Acesse aqui.
• Fonte: https://aws.amazon.com/blogs/machine-learning/boost-inference-performance-for-mixtral-and-llama-2-models-with-new-amazon-sagemaker-containers/