Para implantar uma família de modelos Lama usando o NVIDIA NIM em sua própria nuvem ou máquina local, siga estas etapas:

1. Configurar o Ambiente: Se estiver executando em sua máquina local, instale o mecanismo Docker e o conjunto de ferramentas de contêiner NVIDIA. Os links para esses recursos são fornecidos na descrição do vídeo.

2. Obter a Chave da API: Inscreva-se em uma conta NVIDIA para gerar sua chave da API e chave pessoal. Elas serão necessárias para interagir com o servidor remoto.

3. Executar o Contêiner Docker: Use o comando Docker fornecido para executar o contêiner, especificando o nome do contêiner, o uso da GPU, a chave da API, o local do cache do modelo e a porta. Isso fará o download e a configuração do modelo Lama 3 8 bilhões de instruções.

4. Interagir com o Modelo: Use o comando cURL fornecido para interagir com o modelo implantado. Esse comando segue o padrão da API OpenAI, permitindo que você use o cliente OpenAI para interação.

5. Testar a API sob Estresse: Use um script Python com a biblioteca requests para enviar várias solicitações simultâneas ao endpoint da API e monitorar a utilização da GPU e o desempenho.

6. Usar o Cliente da API OpenAI: Demonstre como usar o cliente da API OpenAI com o NVIDIA NIM, atualizando a URL base e outros parâmetros para corresponder ao modelo implantado.

O NVIDIA NIM fornece uma maneira conveniente e otimizada de implantar modelos de linguagem de grande porte para inferência, com a capacidade de alcançar até 3 vezes melhor desempenho em comparação com outras opções de implantação. O teste gratuito de 90 dias permite que você explore ainda mais essa solução.

Para acessar o NVIDIA Launchpad e o painel de métricas da GPU, siga estas etapas:

1. Como parte do NVIDIA Launchpad, você tem acesso a um IDE de código, que é o Visual Studio Code. Você pode usar esse IDE para interagir com a instância da GPU e implantar o modelo Llama 3 8 bilhões de instruções.

2. O painel de métricas da GPU é um painel Grafana que fornece informações detalhadas sobre o uso e o desempenho da GPU. Você pode acessar esse painel para monitorar a utilização da GPU, a versão do CUDA, os drivers da GPU e outras métricas relevantes.

3. O painel Grafana fornece uma representação visual do uso da GPU ao longo do tempo, permitindo que você acompanhe o desempenho e otimize a implantação de acordo.

4. Você pode usar o comando watch no terminal para monitorar o uso da GPU em tempo real. O comando watch -n 1 nvidia-smi atualizará o uso da GPU a cada segundo, fornecendo uma visão ao vivo da utilização da GPU.

5. O painel de métricas da GPU e as ferramentas de monitoramento em tempo real permitem que você entenda as características de desempenho da implantação do modelo Llama 3 8 bilhões de instruções, ajudando-o a otimizar a utilização de recursos e garantir uma inferência eficiente.

Para implantar o modelo Llama 3 8 bilhões de instruções usando o NVIDIA NIM, siga estas etapas:

1. Abra o IDE fornecido e certifique-se de ter acesso a uma GPU H100.
2. Configure sua chave da API inscrevendo-se em uma conta NVIDIA e gerando as chaves necessárias.
3. Execute o seguinte comando Docker para iniciar o contêiner NVIDIA NIM:

docker run -it --gpus all -e NVIDIA_API_KEY=$NVIDIA_API_KEY -p 8000:8000 --name llama-3-8b-instruct nvcr.io/nvidia/nim:latest --model-name llama-3-8b-instruct

Esse comando irá:

• Criar um contêiner Docker chamado "llama-3-8b-instruct"
• Usar todas as GPUs disponíveis no sistema
• Definir a variável de ambiente NVIDIA_API_KEY
• Expor a porta 8000 para o servidor NIM
• Usar o modelo "llama-3-8b-instruct" do catálogo NVIDIA NIM

4. Depois que o contêiner estiver em execução, você pode usar o comando cURL fornecido para interagir com o modelo:

curl -X POST -H "Content-Type: application/json" -d '{"model": "llama-3-8b-instruct", "prompt": "Tell me a joke.", "max_tokens": 1000, "temperature": 0.7, "top_p": 0.95, "stop": ["\n"]}' http://localhost:8000/v1/completions

Esse comando cURL envia uma solicitação ao servidor NIM em execução no localhost:8000 para gerar uma resposta para o prompt "Tell me a joke."

5. Para testar o endpoint da API sob estresse, você pode executar o script Python test_server.py fornecido. Esse script enviará várias solicitações simultâneas ao servidor NIM e monitorará a utilização da GPU.

6. Finalmente, você também pode usar o cliente da API OpenAI para interagir com o servidor NIM, atualizando a URL base para apontar para o endereço e a porta do servidor NIM.

Seguindo essas etapas, você pode implantar com sucesso o modelo Llama 3 8 bilhões de instruções usando o contêiner Docker NVIDIA NIM e testar seu desempenho.

Para interagir com a API NVIDIA NIM, podemos usar um simples comando cURL. O comando cURL fornece o seguinte:

• Faz uma solicitação POST para o host local na porta 8000, que é onde o servidor NVIDIA NIM está em execução.
• Usa a API compatível com OpenAI, para que possamos usar o cliente OpenAI para interagir com o servidor NIM.
• Especifica o modelo Llama 3 8 bilhões de instruções a ser usado.
• Define a estrutura da mensagem semelhante ao que o OpenAI espera.
• Permite definir parâmetros adicionais como max_tokens e temperature.

Aqui está o comando cURL:

curl -X POST -H "Content-Type: application/json" -d '{"model": "nlp/lama-3-8b-instruct", "messages": [{"role": "user", "content": "Tell me a joke"}], "max_tokens": 1000, "temperature": 0.7}' http://localhost:8000/v1/chat/completions

Esse comando cURL enviará uma solicitação ao servidor NVIDIA NIM, que então gerará uma resposta do modelo Llama 3 8 bilhões de instruções. A resposta será transmitida de volta, com cada token sendo exibido à medida que é gerado.

Para testar ainda mais o endpoint da API sob estresse, podemos usar um script Python que utiliza a biblioteca requests para fazer várias solicitações simultâneas. Esse script enviará 50 solicitações de geração de piadas em paralelo e monitorará a utilização da GPU e o desempenho.

Para testar o endpoint da API NVIDIA NIM sob estresse, usaremos um script Python simples que aproveita a biblioteca requests para fazer várias solicitações simultâneas à API. Aqui está como funciona:

1. Definimos a URL do endpoint da API, que neste caso é o host local, já que estamos executando o servidor localmente. Se você fosse implantar isso em um servidor remoto, precisaria usar o endereço IP externo e habilitar o encaminhamento de portas.

2. Definimos os cabeçalhos necessários, incluindo o cabeçalho Content-Type como application/json.

3. Criamos o payload, que inclui o nome do modelo ("model": "llama-3-8b-instruct"), o prompt ("prompt": "Tell me 50 jokes."``) e outros parâmetros como max_tokens, temperatureestop`.

4. Definimos uma função send_requests() que envia as solicitações usando o método requests.post() e a URL, cabeçalhos e payload que definimos anteriormente.

5. Usamos multithreading para executar várias instâncias da função send_requests() concorrentemente, simulando um alto volume de solicitações ao endpoint da API.

6. Monitoramos o uso da GPU em tempo real usando o comando watch e a ferramenta nvidia-smi, que fornece informações sobre a utilização da GPU.

A saída mostra que o endpoint da API é capaz de lidar com um número significativo de solicitações simultâneas, com uma taxa de transferência média de cerca de 2.500 tokens por segundo. A utilização da GPU também permanece relativamente alta, indicando que o NVIDIA NIM está aproveitando efetivamente os recursos de hardware para fornecer inferência de alto desempenho.

Esse teste de estresse demonstra a escalabilidade e o desempenho da solução NVIDIA NIM, tornando-a uma opção atraente para implantar modelos de linguagem de grande porte em um ambiente de produção.

Para usar o cliente da API OpenAI com o NVIDIA NIM, siga estas etapas:

1. Altere a URL base para a URL da sua instância NVIDIA NIM. Neste exemplo, estamos executando-a em localhost:8000:

openai.api_base = "http://localhost:8000"

2. Você não precisa fornecer a chave da API, pois o NVIDIA NIM cuida da autenticação.

3. Defina o modelo para o modelo hospedado no NVIDIA NIM, neste caso, "meta-llama-38b-instruct":

model = "meta-llama-38b-instruct"

4. Defina os outros parâmetros, como o número máximo de tokens a serem gerados, a temperatura e se você deseja transmitir as respostas:

response = openai.ChatCompletion.create(
    model=model,
    messages=[{"role": "user", "content": "Tell me 50 different jokes"}],
    max_tokens=1024,
    temperature=0.7,
    stream=True,
)

5. Itere pela resposta de streaming e imprima o texto gerado:

for chunk in response:
    print(chunk.choices[0].text, end="")

Essa abordagem permite que você aproveite o desempenho e a facilidade de implantação fornecidos pelo NVIDIA NIM, enquanto usa o cliente da API OpenAI familiar. A resposta de streaming garante que você obtenha o texto gerado em tempo real, proporcionando uma experiência de usuário responsiva.

Neste vídeo, exploramos como implantar um modelo Lama 3 8 bilhões de instruções usando o NVIDIA NIM em sua própria nuvem ou máquina local. O NVIDIA NIM é um conjunto de microsserviços desenvolvidos pela NVIDIA que acelera a implantação de modelos fundamentais, incluindo modelos de linguagem e outros modelos de IA.

Percorremos as etapas para configurar o ambiente NVIDIA NIM, incluindo gerar a chave da API e executar o contêiner Docker para implantar o modelo Lama 3. Também testamos o desempenho do modelo implantado, enviando várias solicitações simultaneamente e monitorando a utilização da GPU e o desempenho.

Além disso, mostramos como usar o cliente da API OpenAI para interagir com o modelo implantado pelo NVIDIA NIM, demonstrando a compatibilidade com o padrão da API OpenAI.

Em geral, o NVIDIA NIM fornece uma maneira conveniente e eficiente de implantar modelos de linguagem de grande porte em um ambiente de produção. A capacidade de aproveitar o conjunto de hardware e software da NVIDIA pode levar a melhorias significativas de desempenho em comparação com outras opções de implantação. Se você estiver interessado em explorar mais opções de implantação para seus projetos, certifique-se de se inscrever no canal para obter conteúdo futuro sobre VLLM e outros tópicos relacionados.