Observação:

• Este tutorial requer acesso ao Oracle Cloud. Para se inscrever em uma conta gratuita, consulte Conceitos básicos do Oracle Cloud Infrastructure Free Tier.
• Ele usa valores de exemplo para credenciais, tenancy e compartimentos do Oracle Cloud Infrastructure. Ao concluir seu laboratório, substitua esses valores por valores específicos do seu ambiente de nuvem.

Ajuste e Atenda a Modelos de Linguagem Grande no Oracle Cloud Infrastructure com o dstack

Introdução

dstack é uma ferramenta de código aberto que simplifica a orquestração de contêineres de Inteligência Artificial (IA) e torna o treinamento distribuído e a implantação de LLMs (Large Language Models) mais acessíveis. A combinação de dstack e Oracle Cloud Infrastructure (OCI) desbloqueia um processo simplificado para configurar a infraestrutura de nuvem para treinamento distribuído e implantação de modelo escalável.

Como o dstack funciona?

O dstack oferece uma interface unificada para o desenvolvimento, o treinamento e a implementação de modelos de IA em qualquer nuvem ou data center. Por exemplo, você pode especificar uma configuração para uma tarefa de treinamento ou um modelo a ser implantado, e dstack cuidará da configuração da infraestrutura necessária e da orquestração dos contêineres. Uma das vantagens que o dstack oferece é que ele permite o uso de qualquer hardware, frameworks e scripts.

Objetivos

• Ajuste um modelo LLM usando dstack na OCI, incorpore as melhores práticas do Hugging Face Alignment Handbook e implemente o modelo usando o Hugging Face Text Generation Inference (TGI).

  Observação: O experimento descrito no tutorial usa um cluster do OCI de três nós, cada um com GPUs 2 x A10, para ajustar o modelo Gemma 7B.

Pré-requisitos

• Acesso a uma tenancy do OCI.

• Acesso a formas com GPU NVIDIA, como GPUs A10 (por exemplo, VM.GPU.A10.2). Para obter mais informações sobre solicitações para aumentar o limite, consulte Limites do Serviço.

• Uma conta do Hugging Face com um token de acesso configurado para fazer download do modelo Gemma 7B.

Tarefa 1: Configurar dstack com o OCI

1. Instale o pacote Python dstack usando o comando a seguir. Como o dstack suporta vários provedores de nuvem, podemos restringir o escopo ao OCI.

   pip install dstack[oci]
   

2. Configure as credenciais específicas do OCI dentro do arquivo ~/.dstack/server/config.yml. O código a seguir pressupõe que você tenha credenciais para a CLI (Interface de Linha de Comando) do OCI configuradas. Para obter outras opções de configuração, consulte a documentação dodstack.

   projects:
   - name: main
     backends:
     - type: oci
       creds:
         type: default
   

3. Execute o servidor dstack usando o comando a seguir.

   dstack server
   INFO     Applying ~/.dstack/server/config.yml...
   INFO     Configured the main project in ~/.dstack/config.yml
   INFO     The admin token is ab6e8759-9cd9-4e84-8d47-5b94ac877ebf
   INFO     The dstack server 0.18.4 is running at http://127.0.0.1:3000
   

4. Alterne para a pasta com seus scripts de projeto e inicialize dstack usando o comando a seguir.

   dstack init
   

Tarefa 2: Tarefa de ajuste fino no OCI com dstack

Para ajustar o modelo Gemma 7B, usaremos o Hugging Face Alignment Handbook para garantir a incorporação das melhores práticas de ajuste fino. O código-fonte deste tutorial pode ser obtido aqui: GitHub. Vamos mergulhar nos passos práticos para ajustar seu LLM.

Depois de alternar para a pasta do projeto, use os comandos a seguir para iniciar o job de ajuste fino no OCI com dstack.

ACCEL_CONFIG_PATH=fsdp_qlora_full_shard.yaml \
  FT_MODEL_CONFIG_PATH=qlora_finetune_config.yaml \
  HUGGING_FACE_HUB_TOKEN=xxxx \
  WANDB_API_KEY=xxxx \
  dstack run . -f ft.task.dstack.yml

As variáveis de ambiente FT_MODEL_CONFIG_PATH, ACCEL_CONFIG_PATH, HUGGING_FACE_HUB_TOKEN e WANDB_API_KEY são definidas dentro da configuração da tarefa ft.task.dstack.yml. dstack run submete a tarefa definida em ft.task.dstack.yml no OCI.

Observação: dstack copia automaticamente o conteúdo do diretório atual ao executar a tarefa.

Vamos explorar as partes-chave de cada arquivo YAML (para o conteúdo completo, verifique o repositório).

O arquivo qlora_finetune_config.yaml é a configuração da receita que o Manual de Alinhamento usa para entender como você deseja ajustar um modelo de idioma grande (LLM).

# Model arguments
model_name_or_path: google/gemma-7b
tokenizer_name_or_path: philschmid/gemma-tokenizer-chatml
torch_dtype: bfloat16
bnb_4bit_quant_storage: bfloat16

# LoRA arguments
load_in_4bit: true
use_peft: true
lora_r: 8
lora_alpha: 16
lora_dropout: 0.05
lora_target_modules:
  - q_proj
  - k_proj
# ...

# Data training arguments
dataset_mixer:
  chansung/mental_health_counseling_conversations: 1.0
dataset_splits:
  - train
  - test
# ...

• Argumentos do Modelo:

  • model_name_or_path: O Gemma 7B do Google é escolhido como o modelo base.
  • tokenizer_name_or_path: O Manual de Alinhamento usa o método apply_chat_template() do tokenizador escolhido. Este tutorial usa o modelo ChatML em vez do modelo de conversa padrão do Gemma 7B.
  • torch_dtype e bnb_4bit_quant_storage: Esses dois valores devem ser definidos da mesma forma se quisermos aproveitar o método de ajuste fino FSDP+QLoRA. Como o Gemma 7B é difícil de ajustar em uma única GPU A10, este tutorial usa FSDP+QLoRA para fragmentar um modelo em GPUs 2 x A10 enquanto aproveita a técnica QLoRA.

• LoRA Argumentos: LoRA configurações específicas. Como este post do tutorial aproveita a técnica FSDP+QLoRA, load_in_4bit é definido como true. Outras configurações podem variar de experimento para experimento.

• Argumentos de Treinamento de Dados: Preparamos um conjunto de dados baseado no conjunto de dados das conversas de aconselhamento em saúde mental da Amod. Como o manual de alinhamento só entende os dados na forma de [{"role": "user", "content": "..."}, {"role": "assistant", "content": "..."}, …], que pode ser interpretado com o método apply_chat_template() do tokenizer, o conjunto de dados preparado é basicamente a conversão do conjunto de dados original no formato compatível com apply_chat_template().

As configurações do arquivo fsdp_qlora_full_shard.yaml aceleram como usar a infraestrutura subjacente para ajustar o LLM.

compute_environment: LOCAL_MACHINE
distributed_type: FSDP  # Use Fully Sharded Data Parallelism
fsdp_config:
  fsdp_auto_wrap_policy: TRANSFORMER_BASED_WRAP
  fsdp_backward_prefetch: BACKWARD_PRE
  fsdp_cpu_ram_efficient_loading: true
  fsdp_use_orig_params: false
  fsdp_offload_params: true
  fsdp_sharding_strategy: FULL_SHARD
  # ... (other FSDP configurations)
# ... (other configurations)

• distributed_type: FSDP indica o uso do FSDP (Fully Sharded Data Parallel), uma técnica que permite o treinamento de modelos grandes que, de outra forma, não caberiam em uma única GPU.
• fsdp_config: Isso configura como o FSDP opera, como como o modelo é particionado (fsdp_sharding_strategy) e se os parâmetros são descarregados para a CPU (fsdp_offload_params).

Com o FSDP de distributed_type e o FULL_SHARD de fsdp_config do fsdp_sharding_strategy, um modelo será particionado em várias GPUs em uma única máquina. Ao lidar com vários nós de computação, cada nó hospedará uma cópia idêntica do modelo, que é dividido em várias GPUs dentro desse nó. Isso significa que cada instância de modelo particionado em cada nó processa diferentes seções ou lotes de seu conjunto de dados. Para distribuir um único modelo entre várias GPUs que se estendem por vários nós, configure o parâmetro fsdp_sharding_strategy como HYBRID_SHARD.

Parâmetros adicionais como machine_rank, num_machines e num_processes são importantes para coordenação. No entanto, é recomendável definir esses valores dinamicamente no runtime, pois isso oferece flexibilidade ao alternar entre diferentes configurações de infraestrutura.

Tarefa 3: Instruir dstack usando Configuração Simplificada para Provisionar Infraestrutura

Vamos explorar a configuração fsdp_qlora_full_shard.yaml que reúne tudo e instrui dstack sobre como provisionar a infraestrutura e executar a tarefa.

type: task
nodes: 3

python: "3.11"
env:
  - ACCEL_CONFIG_PATH
  - FT_MODEL_CONFIG_PATH
  - HUGGING_FACE_HUB_TOKEN
  - WANDB_API_KEY
commands:
  # ... (setup steps, cloning repo, installing requirements)
  - ACCELERATE_LOG_LEVEL=info accelerate launch \
      --config_file recipes/custom/accel_config.yaml \
      --main_process_ip=$DSTACK_MASTER_NODE_IP \
      --main_process_port=8008 \
      --machine_rank=$DSTACK_NODE_RANK \
      --num_processes=$DSTACK_GPUS_NUM \
      --num_machines=$DSTACK_NODES_NUM \
      scripts/run_sft.py recipes/custom/config.yaml
ports:
  - 6006
resources:
  gpu: 1..2
  shm_size: 24GB

Pontos-chave a serem destacados::

• Integração perfeita: dstack integra-se facilmente com o ecossistema de código aberto Hugging Face. Especificamente, você pode simplesmente usar a biblioteca de aceleração com as configurações que definimos em fsdp_qlora_full_shard.yaml como normais.
• Configuração Automática: as variáveis DSTACK_MASTER_NODE_IP, DSTACK_NODE_RANK, DSTACK_GPUS_NUM e DSTACK_NODES_NUM são gerenciadas automaticamente por dstack, reduzindo a configuração manual.
• Alocação de Recursos: dstack facilita a especificação do número de nós e GPUs (gpu: 1..2) para seu job de ajuste fino. Portanto, para este tutorial, há três nós, cada um dos quais está equipado com GPUs 2 x A10 (24 GB).

Tarefa 4: Atenda ao seu Modelo Ajustado com dstack

Depois que seu modelo é ajustado, o dstack facilita a implementação dele na OCI usando a estrutura TGI (Hugging Face Text Generation Inference).

Veja um exemplo de como você pode definir um serviço em dstack:

type: service
image: ghcr.io/huggingface/text-generation-inference:latest
env:
  - HUGGING_FACE_HUB_TOKEN
  - MODEL_ID=chansung/mental_health_counseling_merged_v0.1
commands:
  - text-generation-launcher \
    --max-input-tokens 512 --max-total-tokens 1024 \
    --max-batch-prefill-tokens 512 --port 8000
port: 8000

resources:
  gpu:
    memory: 48GB

# (Optional) Enable the OpenAI-compatible endpoint
model:
  format: tgi
  type: chat
  name: chansung/mental_health_counseling_merged_v0.1

Principais vantagens desta abordagem:

• Gateway HTTPS Seguro: dstack simplifica o processo de configuração de uma conexão HTTPS segura por meio de um gateway, um aspecto crucial do serviço de modelo no nível de produção.
• Otimizado para Inferência: A estrutura TGI foi projetada para inferência de geração de texto eficiente, garantindo que seu modelo forneça resultados responsivos e confiáveis.
• Dimensionamento automático: dstack permite especificar a política de dimensionamento automático, incluindo o número mínimo e máximo de réplicas de modelo.

Nesse ponto, você pode interagir com o serviço usando o comando curl padrão e solicitações Python, o SDK OpenAI e as bibliotecas do Cliente de Inferência do Hugging Face. Por exemplo, o trecho de código a seguir mostra um exemplo de curl.

curl -X POST https://black-octopus-1.mycustomdomain.com/generate \
  -H "Authorization: Bearer <dstack-token>" \
  -H 'Content-Type: application/json' \
  -d '{"inputs": "I feel bad...", "parameters": {"max_new_tokens": 128}}'

Além disso, para um modelo implantado, o dstack fornece automaticamente uma interface de usuário para interagir diretamente com o modelo.

Próximas Etapas

Ao seguir as etapas descritas neste tutorial, você desbloqueou uma abordagem avançada para ajustar e implementar LLMs usando os recursos combinados de dstack, OCI e o ecossistema Hugging Face. Agora você pode aproveitar a interface amigável do dstack para gerenciar seus recursos da OCI de forma eficaz, simplificando o processo de configuração de ambientes de treinamento distribuídos para seus projetos de LLM.

Além disso, a integração com o Manual de Alinhamento do Hugging Face e a estrutura TGI permite que você ajuste e atenda seus modelos perfeitamente, garantindo que eles sejam otimizados para desempenho e prontos para aplicativos do mundo real. Incentivamos você a explorar ainda mais as possibilidades e experimentar diferentes modelos e configurações para alcançar os resultados desejados no mundo do processamento de linguagem natural.

Agradecimentos

• Autor - Chansung Park (HuggingFace fellow - pesquisador de IA), Yann Caniou (Especialista em Infraestrutura de IA/GPU), Bruno Garbaccio (Especialista em Infraestrutura de IA/GPU)

Mais Recursos de Aprendizagem

Explore outros laboratórios em docs.oracle.com/learn ou acesse mais conteúdo de aprendizado gratuito no canal Oracle Learning YouTube. Além disso, visite education.oracle.com/learning-explorer para se tornar um Oracle Learning Explorer.

Para obter a documentação do produto, visite o Oracle Help Center.

---

Título e Informações de Copyright

Fine-Tune and Serve Large Language Models on Oracle Cloud Infrastructure with dstack

G11979-01

July 2024

Copyright ©2024,

Oracle e/ou suas empresas afiliadas.