Desenvolvendo com Llama2 na Google Cloud

Uma imagem de uma llama com óculos escuros (gerada pelo modelo Imagen da Google Cloud)

Introdução

Faz um tempo que apareço por aqui e muita coisa aconteceu desde a última postagem — Rolou o Live+Labs São Paulo, o Google Cloud Next com diversas novidades, bonde de Cloud AI de Google Cloud Brasil colou no TDC Business 2023 e o Google Cloud Summit Brasil… ufa!

Tem muita novidade legal que vou trazer aqui nos próximos posts… Mas uma em especial que eu queria trazer hoje: o LlaMA2 — um modelo de linguagem gigante (ou Large Language Model, ou LLM), auto-regressivo baseado em transformers, open source e gratuito para uso de pesquisa e comercial desenvolvido pela Meta AI — disponível para uso dentro da Google Cloud!

As principais características técnicas do Llama2 são:

• Treinado em um dataset misto de dados públicos, com cerca de 2T tokens
• Suporte a contextos de 4K tokens
• Vários tamanhos disponíveis: 7B, 13B, 34B e 70B de parâmetros

O paper do Lllama2 tem maiores e mais profundos detalhes sobre o modelo e sua arquitetura.

Desde o Google Cloud Next 2023) você pode utilizar e até realizar fine tuning de várias versões do Llama2 dentro da Google Cloud, utilizando a Vertex AI e a Model Garden.

Antes de exercitarmos o uso do modelo — O que seria a Model Garden?

A Model Garden da Vertex AI

A Model Garden é um biblioteca centralizada de modelos, dentro da Vertex AI, onde você encontra ferramentas e mecanismos para utilizar modelos desenvolvidos pelo Google e alguns open source — tanto de forma diretamente pré-treinada (simplesmente implantando em uma API) ou, para alguns modelos, a habilidade de refinamento (ou fine tuning) com datasets para tarefas específicas.

A visão geral da Model Garden é como abaixo:

Página inicial da Model Garden dentro da console da Vertex AI

É sua primeira vez navegando na Model Garden? Ou não sabe, exatamente, qual modelo você quer utilizar para o seu cenário? Sem problemas! Você encontra na console filtros para casos de uso específico, ou possibilidade de fine tuning, uso de jupyter notebooks, etc:

Alguns dos filtros de busca de modelos da Model Garden: por tarefa, por modalidade e por funcionalidades

Acessando o modelo Llama 2

Neste blog vamos fazer uma experimentação rápida: Como utilizar um modelo direto da Model Garden e implantando em uma API para uso via chamadas REST e/ou chamadas via SDK em Python. Mais especificamente, vamos utilizar o modelo Llama 2.

Primeiro devemos encontrá-lo na Model Garden — fazemos a busca por Llama 2:

Encontrando o modelo Llama 2 realizando uma busca na Model Garden

Caso seja a primeira vez que você entre na página do Llama 2, você terá que ler e aceitar a licença de uso do modelo antes de continuar:

Licença de utilização do modelo Llama 2

Com o termo aceito, você verá a página inicial do Llama 2 dentro da Model Garden incluindo detalhes do modelo e as variantes disponíveis para uso (7B, 13B e 70B de parâmetros):

Aqui vamos implantar o modelo de duas formas: usando a interface de usuário da console e usando a SDK da Vertex AI.

Implantando o Llama 2 usando a console da Vertex AI

Para começar o processo de implantação do modelo, iremos clicar no botão “deploy” (ou “implantar” se sua console estiver em português):

Página inicial do modelo Llama 2 na model Garden com a opção de implantar o modelo pré-treinado

Na primeira tela de implantação do modelo, você deve primeiro escolher qual variante do modelo você quer usar (tendo modelos de geração de texto e chat e em tamanhos diferentes):

Tipos e tamanhos disponíveis para o modelo Llama 2

Após isso você irá escolher o “nome” que o modelo será salvo no seu projeto (ele será "copiado" de um local público para dentro do seu projeto) e em qual região a implantação ocorrerá (aqui no meu caso, deixei na região us-central1):

Nome e região onde a cópia do modelo Llama 2 será salva

Após isso, clique em “save” (ou “salvar”). Na tela seguinte você irá definir as informações de endpoint do modelo — ou o backend que a Vertex AI irá utilizar para implantar o seu modelo. Primeiro você irá escolher o nome do seu endpoint e o tipo de acesso (se será público ou somente em uma rede privada):

Nome do endpoint e método de acesso ao endpoint (público ou privado)

Na tela seguinte você deve escolher a configuração de máquinas que irá ser utilizada no backend do endpoint, se algum acelerador será utilizado (aqui no nosso caso, iremos utilizar uma GPU NVIDIA V100) e a configuração de autoscaling. No meu lab aqui, a configuração ficou como abaixo:

Definições de autoscaling e configurações de máquina para o seu endpoint com a Llama 2

Após isso, você clica em “done” e em “deploy” (ou implantar). Após alguns minutos, seu modelo estará implantado como endpoint da Vertex AI. O modelo aparecerá como salvo na Model Registry da Vertex AI:

Sua cópia do modelo Llama 2 dentro da Model Registry do seu projeto

E também o endpoint aparecerá como disponível como endpoint:

Seu endpoint com o modelo Llama 2 implantado

E se clicarmos no nome do endpoint, podemos confirmar que nosso modelo Llama2 está implantado lá dentro:

Modelo Llama 2 disponível dentro do seu endpoint

Agora vamos ver como realizar este mesmo processo, mas dessa vez via SDK da Vertex AI.

Implantando o Llama 2 usando a SDK da Vertex AI

Para muitas equipes de desenvolvimento, o uso da console não é o mais prático (seja por habilidade com uso de SDK em geral, ou seja pela utilização de ferramentas de automação como Terraform). Assim, iremos realizar também a implantação do Llama 2 utilizando a SDK da Vertex AI.

Dentro da própria Model Garden você encontra um jupyter notebook pronto para isso — basta clicar no botão “Open Notebook” na página do Llama 2 da Model Garden:

Página inicial do modelo Llama 2 na model Garden com a opção de abrir o notebook de exemplo

Para instalar a SDK da Vertex AI no seu ambiente Python, você precisa de apenas um pip install. Ele instalará a SDK da Vertex AI e todos os seus requisitos:

pip install google-cloud-aiplatform

Depois disso, você deve importar os módulos utilizados no resto do código:

import os
import sys
from google.cloud import aiplatform

E definir as variáveis que utilizaremos no código:

# project id que será utilizado no lab
PROJECT_ID = "lucianomartins-demos-345000"

# a região onde realizaremos os testes
REGION = "us-central1"

# as configurações de máquina que serão
# utilizadas no endpoint do modelo
machine_type = "n1-standard-8"
accelerator_type = "NVIDIA_TESLA_V100"
accelerator_count = 1

# precisão utilizada com o modelo
# a recomendação para o uso direto do modelo
# pré-treinado é 'float16'
precision_loading_mode = "float16"

Para fazermos o deploy do modelo, iremos utilizar uma função que chamaremos aqui de deploy_model() como abaixo:

def deploy_model(
model_name,
base_model_name,
task,
precision_loading_mode,
machine_type,
accelerator_type,
accelerator_count,
):

"""Deploys trained models into Vertex AI."""
endpoint = aiplatform.Endpoint.create(display_name="meu-endpoint-llama2–002")
serving_env = {
"BASE_MODEL_ID": base_model_name,
"PRECISION_LOADING_MODE": precision_loading_mode,
"TASK": task,
}

model = aiplatform.Model.upload(
display_name=model_name,
serving_container_image_uri="us-docker.pkg.dev/vertex-ai/vertex-vision-model-garden-dockers/pytorch-peft-serve",
serving_container_ports=[7080],
serving_container_predict_route="/predictions/peft_serving",
serving_container_health_route="/ping",
serving_container_environment_variables=serving_env,
)

model.deploy(
endpoint=endpoint,
machine_type=machine_type,
accelerator_type=accelerator_type,
accelerator_count=accelerator_count,
deploy_request_timeout=1800
)
return model, endpoint

Após isso devemos definir o tipo e a versão do modelo que queremos utilizar:

base_model_name = "gs://vertex-model-garden-public-us-central1/llama2/llama2–7b-hf"

E então realizamos o deploy do modelo:

modelo, endpoint = deploy_model(
model_name="minha-api-llama2–002",
task="causal-language-modeling-lora",
base_model_name=base_model_name,
precision_loading_mode=precision_loading_mode,
machine_type=machine_type,
accelerator_type=accelerator_type,
accelerator_count=accelerator_count)

print("endpoint_name:", endpoint.name)

Ao final desse processo, você deve ver um resultado similar ao abaixo:

Creating Endpoint
Create Endpoint backing LRO: projects/48397268769/locations/us-central1/endpoints/6097612211692240896/operations/559281639033667584
Endpoint created. Resource name: projects/48397268769/locations/us-central1/endpoints/6097612211692240896
To use this Endpoint in another session:
endpoint = aiplatform.Endpoint('projects/48397268769/locations/us-central1/endpoints/6097612211692240896')

Creating Model
Create Model backing LRO: projects/48397268769/locations/us-central1/models/6779137897099427840/operations/6850810318470250496
Model created. Resource name: projects/48397268769/locations/us-central1/models/6779137897099427840@1
To use this Model in another session:
model = aiplatform.Model('projects/48397268769/locations/us-central1/models/6779137897099427840@1')

Deploying model to Endpoint : projects/48397268769/locations/us-central1/endpoints/6097612211692240896
Deploy Endpoint model backing LRO: projects/48397268769/locations/us-central1/endpoints/6097612211692240896/operations/1658159948112068608
Endpoint model deployed. Resource name: projects/48397268769/locations/us-central1/endpoints/6097612211692240896

endpoint_name: 6097612211692240896

Parabéns!! Você finalizou o seu processo de implantação do Llama2–7B utilizando a SDK da Vertex AI!

Realizando inferências com a API implantada com o Llama 2

A última etapa desta nossa experimentação é, finalmente, realizar inferências com o Llama 2. Da mesma forma que realizamos a implantação via console e via SDK da Vertex AI, iremos realizar testes de inferência das duas formas também.

Para o teste via console, você deve ir até a Model Registry e clicar no seu modelo (aqui, tanto faz se você usar o modelo criado via console ou SDK). Na aba “deploy & test” você encontrará uma caixa de texto com o nome “JSON request” como abaixo:

Acessando a tela de teste de endpoints na console da Vertex AI

Para este teste enviaremos a pergunta “what is artificial intelligence?” (ou “o que é inteligência artificial” em português). Estamos enviando a requisição em inglês pois o modelo pré-treinado Llama 2 só suporta oficialmente o idioma Inglês. O JSON da requisição ficará como abaixo:

{
  "instances": [
  {
    "prompt": "what is artificial intelligence?"
  }
  ],
  "parameters": {
    "max_length": 400,
    "top_k": 10
  }
}

A resposta será vista na caixa “response” semelhante a imagem abaixo:

Resultado da inferência realizada via console da Vertex AI

Para realizar a inferência via SDK, só temos que saber o id do endpoint a ser utilizado e enviar a inferência. Algo como abaixo:

# variáveis importantes
PROJECT_ID="lucianomartins-demos-345000"
REGION="us-central1"
ENDPOINT_ID="6097612211692240896"

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

# prompt que será enviado ao modelo
instances = [
{"prompt": "what is artificial intelligence?", "max_length": 400, "top_k": 10},
]

# envio da solicitação à API do Llama2
response = endpoint.predict(instances=instances)

# visualização da resposta
for prediction in response.predictions[0]:
print(prediction["generated_text"])

O resultado será similar ao abaixo:

what is artificial intelligence? It's not just a computer that plays chess better than anyone. But it's more than that as well, because there are things that computers can't do.
There's a lot more involved and there's a lot of different things that we don't fully understand.
And the reason that we don't fully understand is that computers don't have a soul, they don't have emotions. It's really hard for people to understand that. I can't explain it.
I don't know how you feel when you look at a computer screen and you have this feeling, I don't know, this feeling of "oh, that's not real", it's very hard for me to understand how somebody can say, "Oh, that's not real" when they have no emotions.
And that's the kind of thing that makes computers hard to get into computers.
So, it's like a lot of other things that make it harder, I think a lot of people who are trying to get into computers, they're looking at this and saying, "Oh, that's not real, that's a computer", and they don't realize the difference.
I don't think it's a computer in the sense of a machine.
And then you have the whole other side of it, like a human being, and the computer can make you think that's a person.
It's like, "Oh my God, I'm just a human.
And then I can make you say that I'm a computer".
You can have this whole thing, where you're a human being, and you're like, "Wow, you're a machine" and then the computer makes you a human and it makes you a computer.
So you can think you'

Conclusão

De uma forma bem simples, utilizamos a facilidade da Model Garden para implantar e realizar inferências utilizando o modelo Llama 2 desenvolvido pela Meta AI.

O mais interessante da Model Garden é que a interação e o uso são simples para todos os modelos disponíveis — Ou seja, sem muito esforço de infraestrutura e implantação para termos mais tempo para o que realmente importa: Desenvolver com um modelo de machine learning.

Em um próximo blog, vamos juntos na experimentação de fine tuning do Llama2 — ou o processo de incluir “conhecimento” adicional ao modelo via um dataset que contenha informações que o modelo não teve acesso no seu treinamento.

E vocês? Estão nessa jornada com modelos comerciais ou open source? Tem alguma dúvida com esse processo dentro da Google Cloud? Compartilha aí sua jornada e quem sabe não escrevemos o próximo blog sobre isso juntos? 🙂

Um abraço e até a próxima!