Integre Seu Próprio LLM no EA (Parte 4): Treinando Seu Próprio LLM com GPU

Índice

• Introdução
• Preparativos
• Configuração de Hardware
• Ambiente de Desenvolvimento
• Treina o Modelo
• Resumo

Introdução

No artigo anterior, discutimos brevemente como criar conjuntos de dados para modelos de linguagem e demonstramos como treinar um modelo de linguagem usando apenas uma CPU com um exemplo simples. No entanto, não testamos o modelo, pois, em termos reais, ele era apenas um modelo pré-treinado. Neste artigo, continuamos nossa discussão sobre o treinamento de modelos, desta vez usando GPUs para acelerar o processo. É importante notar que, como exemplo de demonstração, esse modelo ainda não é poderoso o suficiente, então não abordaremos o teste do modelo neste artigo. O teste será tratado em artigos subsequentes.  

Anteriormente, cobrimos a configuração de ambientes de aceleração CUDA na segunda parte desta série. Agora, vamos nos concentrar no uso de placas gráficas AMD para acelerar o treinamento, o que serve como um complemento ao artigo anterior. Atualmente, configurar um ambiente de placa gráfica NVIDIA é relativamente direto, enquanto configurar um ambiente para placas AMD pode apresentar diversos desafios. Neste artigo, forneceremos soluções para problemas comuns, permitindo que você acelere tranquilamente o treinamento do seu próprio modelo de linguagem financeira usando placas gráficas AMD. Se você estiver usando placas gráficas NVIDIA, não se preocupe — os métodos de treinamento são os mesmos. Desde que você já tenha configurado o ambiente CUDA, pode seguir as instruções de treinamento fornecidas neste artigo sem precisar se concentrar nas etapas específicas de configuração para placas AMD.  

Está pronto para começar? 

Preparativos

Em um artigo anterior desta série, abordamos a configuração de ambientes NVIDIA. No entanto, não devemos ignorar o fato de que alguns usuários estão trabalhando com hardware AMD. Portanto, também discutiremos a configuração do ambiente de computação de aceleração ROCm (Radeon Open Compute). Até o momento, não há uma versão do PyTorch com suporte para ROCm disponível para Windows, e o WSL (Subsistema do Windows para Linux) ainda não suporta ROCm. Assim, se você quiser usar o ROCm para treinar grandes modelos, o Linux (especificamente o Ubuntu) é atualmente a opção viável (Em uma nota positiva, a próxima versão do ROCm pode adicionar suporte para WSL no futuro, mas a versão mais recente atual é a 6.1.2, e eu não espero que a primeira versão com suporte seja ideal.). Durante o meu uso, encontrei vários problemas relacionados ao hardware AMD que não enfrentei com a NVIDIA. Vou compartilhar algumas soluções que acredito que podem ser úteis para os usuários AMD. Embora possa ser um pouco trabalhoso, lembre-se de que estamos economizando dinheiro, certo? Ah-ha…  

Então, se você quiser acelerar o treinamento de grandes modelos de linguagem usando placas gráficas AMD, aqui estão os preparativos necessários:     

1. Instale o Ubuntu  

Você precisará instalar um sistema Ubuntu. Configurar um sistema de inicialização dupla com Windows e Ubuntu no mesmo PC é viável e recomendado. Pode ser que precisemos acessar dados do sistema Windows, então ter ambas as opções de sistema operacional é útil. Tutoriais detalhados para configurar um sistema de inicialização dupla estão amplamente disponíveis online. Alternativamente, você pode implantar seu dispositivo AMD como um host remoto Ubuntu e usá-lo como um ambiente de desenvolvimento remoto. Você pode então conectar-se ao host remoto via SSH a partir do seu sistema Windows. Essa abordagem é semelhante ao uso do WSL no Windows, com a principal diferença sendo que placas gráficas AMD não suportam o WSL. Perguntei aos desenvolvedores do ROCm sobre isso, e eles mencionaram que o suporte ao WSL está em desenvolvimento (possivelmente disponível na próxima versão). No entanto, tenha em mente que essa solução pode exigir que você tenha múltiplos computadores. Pessoalmente, estou usando esse método.  

2. Verifique a Configuração de Hardware 

Seja cauteloso com sua configuração de hardware. Por exemplo, enfrentei falhas frequentes de driver com minha placa gráfica 7900XTX. Inicialmente, eu usava uma fonte de alimentação de 850W, que deveria ser suficiente para uma GPU única. No entanto, não considerei que as falhas de driver poderiam estar relacionadas a problemas na fonte de alimentação. Após tentar várias soluções sem sucesso, um amigo sugeriu atualizar para uma fonte de 1250W, e tudo funcionou perfeitamente.

Então, aqui vai um conselho sincero para todos os usuários de hardware AMD: Certifique-se de que sua fonte de alimentação pode lidar com seus dispositivos.  

3. ROCM and HIP   

Se você prefere uma configuração de ambiente menos complicada, pode usar a imagem Docker oficial da AMD. Basta puxar a imagem do contêiner oficial do ROCm usando o Docker. A maioria das configurações de ambiente necessárias já estão configuradas na imagem Docker, por isso recomendo essa abordagem.

4. Configurações de Hardware

Durante o uso do dispositivo, notei que a otimização do driver AMDGPU no Ubuntu não é tão boa. Pegue minha 7900XTX como exemplo: Embora possa gerar 350W de potência, o limite padrão estava definido para 303W. Além disso, mesmo sob carga total, a velocidade do ventilador era inferior a 45%, e a temperatura do núcleo permanecia em 100°C. Para o treinamento de verdadeiros modelos grandes, que pode rodar continuamente por várias horas ou até dias, manter temperaturas tão altas é arriscado para o dispositivo.  

Sentindo-se tentado a trocar de dispositivo de hardware agora? Confie em mim, há mais por vir…  

Configuração de Hardware

1. Configuração do Driver

Até o momento, o driver amdgpu no Ubuntu fornece algumas interfaces externas para configurações de GPU. Os arquivos de configuração estão localizados em "/sys/class/drm/card0/device/hwmon/hwmon2/". Note que "hwmon2" pode variar; pode ser "hwmon1" ou outro valor. Ajuste-o de acordo com seu dispositivo específico. Recomendo ajustar a velocidade do ventilador e a potência de forma apropriada, mas evite modificar outras configurações.  

Vamos ilustrar como configurar a velocidade do ventilador. Essas operações de arquivo exigem privilégios de administrador, caso contrário, você não poderá fazer alterações. Recomendo usar o usuário root para as modificações:    

• Primeiro, habilite pwm1: echo "1" > /sys/class/drm/card0/device/hwmon/hwmon2/pwm1_enable
• Aplique a configuração: echo "c" > /sys/class/drm/card0/device/hwmon/hwmon2/pwm1_enable

Defina a velocidade do ventilador para 128. O valor pode variar de 0 a 255, onde 255 corresponde à velocidade máxima do ventilador..

• Ajuste conforme necessário: echo "128" > /sys/class/drm/card0/device/hwmon/hwmon2/pwm1
• Aplique a configuração: echo "c" > /sys/class/drm/card0/device/hwmon/hwmon2/pwm1     

Ajuste o limite de potência. Por exemplo, se sua 7900XTX tem uma potência máxima de 350W e o padrão é 303W:

• Modifique para 330W: echo "330000000" > /sys/class/drm/card0/device/hwmon/hwmon2/power1_cap
• Aplique a configuração: echo "c" > /sys/class/drm/card0/device/hwmon/hwmon2/power1_cap   

Notas:   

1. Para reverter as configurações, use echo "r" > seguido pelo caminho relevante (por exemplo, echo "r" > /sys/class/drm/card0/device/hwmon/hwmon2/pwm1_enable).  

2. Evite definir velocidades de ventilador simultaneamente através das interfaces "pwm1" e "fan[1-*]_target", pois a última substituirá a primeira.     

2. Configurações ROCM-SMI

Abaixo estão comandos comumente usados para rocm-smi: 

usage: rocm-smi [-h] [-V] [-d DEVICE [DEVICE ...]] [--alldevices] [--showhw] [-a] [-i] [-v] [-e [EVENT ...]]
                [--showdriverversion] [--showtempgraph] [--showfwinfo [BLOCK ...]] [--showmclkrange] [--showmemvendor]
                [--showsclkrange] [--showproductname] [--showserial] [--showuniqueid] [--showvoltagerange] [--showbus]
                [--showpagesinfo] [--showpendingpages] [--showretiredpages] [--showunreservablepages] [-f] [-P] [-t]
                [-u] [--showmemuse] [--showvoltage] [-b] [-c] [-g] [-l] [-M] [-m] [-o] [-p] [-S] [-s]
                [--showmeminfo TYPE [TYPE ...]] [--showpids [VERBOSE]] [--showpidgpus [SHOWPIDGPUS ...]]
                [--showreplaycount] [--showrasinfo [SHOWRASINFO ...]] [--showvc] [--showxgmierr] [--showtopo]
                [--showtopoaccess] [--showtopoweight] [--showtopohops] [--showtopotype] [--showtoponuma]
                [--showenergycounter] [--shownodesbw] [--showcomputepartition] [--showmemorypartition] [-r]
                [--resetfans] [--resetprofile] [--resetpoweroverdrive] [--resetxgmierr] [--resetperfdeterminism]
                [--resetcomputepartition] [--resetmemorypartition] [--setclock TYPE LEVEL] [--setsclk LEVEL [LEVEL ...]]
                [--setmclk LEVEL [LEVEL ...]] [--setpcie LEVEL [LEVEL ...]] [--setslevel SCLKLEVEL SCLK SVOLT]
                [--setmlevel MCLKLEVEL MCLK MVOLT] [--setvc POINT SCLK SVOLT] [--setsrange SCLKMIN SCLKMAX]
                [--setextremum min|max sclk|mclk CLK] [--setmrange MCLKMIN MCLKMAX] [--setfan LEVEL]
                [--setperflevel LEVEL] [--setoverdrive %] [--setmemoverdrive %] [--setpoweroverdrive WATTS]
                [--setprofile SETPROFILE] [--setperfdeterminism SCLK]
                [--setcomputepartition {CPX,SPX,DPX,TPX,QPX,cpx,spx,dpx,tpx,qpx}]
                [--setmemorypartition {NPS1,NPS2,NPS4,NPS8,nps1,nps2,nps4,nps8}] [--rasenable BLOCK ERRTYPE]
                [--rasdisable BLOCK ERRTYPE] [--rasinject BLOCK] [--gpureset] [--load FILE | --save FILE]
                [--autorespond RESPONSE] [--loglevel LEVEL] [--json] [--csv]

Opções de configuração:
--setclock TIPO NÍVEL                            Definir Nível de Frequência do Clock para o clock especificado (requer nível de Perf manual)
--setsclk NÍVEL [NÍVEL ...]                       Definir Nível de Frequência do Clock da GPU (requer nível de Perf manual)
--setmclk NÍVEL [NÍVEL ...]                      Definir Nível de Frequência do Clock de Memória da GPU (requer nível de Perf manual)
--setpcie NÍVEL [NÍVEL ...]                     Definir Nível de Frequência do Clock do PCIE (requer nível de Perf manual)
--setslevel SCLKLEVEL SCLK SVOLT            Alterar frequência do clock da GPU (MHz) e tensão (mV) para um nível específico
--setmlevel MCLKLEVEL MCLK MVOLT         Alterar frequência do clock de memória da GPU (MHz) e tensão (mV) para um nível específico
--setvc PONTO SCLK SVOLT                        Alterar Curva de Tensão SCLK (MHz mV) para um ponto específico
--setsrange SCLKMIN SCLKMAX                 Definir velocidade mínima e máxima do SCLK
--setextremum min|max sclk|mclk CLK      Definir velocidade mínima/máxima do SCLK/MCLK
--setmrange MCLKMIN MCLKMAX                Definir velocidade mínima e máxima do MCLK
--setfan NÍVEL                                          Definir Velocidade do Ventilador da GPU (Nível ou %)
--setperflevel NÍVEL                                  Definir Nível de Performance
--setoverdrive %                      Definir nível de OverDrive da GPU (requer nível de Perf manual|alto)
--setmemoverdrive %                                 Definir nível de Overclock de Memória da GPU (requer nível de Perf manual|alto)
--setpoweroverdrive WATTS                      Definir potência máxima da GPU usando Power OverDrive em Watts
--setprofile SETPROFILE                            Especificar nível de Perfil de Potência (#) ou uma string de atributos de Perfil PERSONALIZADO "# # # #..." (requer nível de Perf manual)

  --setperfdeterminism SCLK                     Definir limite de frequência do clock para obter variação mínima de performance

  --setcomputepartition {CPX,SPX,DPX,TPX,QPX,cpx,spx,dpx,tpx,qpx}  Definir partição de computação
--setmemorypartition {NPS1,NPS2,NPS4,NPS8,nps1,nps2,nps4,nps8}   Definir partição de memória
--rasenable BLOCO TIPODEERRO                  Habilitar RAS para o bloco e tipo de erro especificados
--rasdisable BLOCO TIPODEERRO                 Desabilitar RAS para o bloco e tipo de erro especificados
--rasinject BLOCO                                     Injetar falha RAS para o bloco especificado (FUNCIONA APENAS EM PLACAS INSEGURAS)

Opções de reinicialização:
-r, --resetclocks                                                 Redefinir clocks e OverDrive para padrão
--resetfans                                                        Redefinir ventiladores para controle automático (driver)
--resetprofile                                                     Redefinir Perfil de Potência para o padrão
--resetpoweroverdrive                                       Definir a potência máxima da GPU de volta para o estado padrão do dispositivo
--resetxgmierr                                                 Redefinir contagem de erros do XGMI
--resetperfdeterminism                                  Desabilitar determinação de performance
--resetcomputepartition                                    Redefinir para o estado inicial da partição de computação
--resetmemorypartition                                    Redefinir para o estado inicial da partição de memória

Opções de resposta automática:
--autorespond RESPOSTA                              Resposta para fornecer automaticamente para todos os prompts (NÃO RECOMENDADO)

Opções de saída:
--loglevel NÍVEL                           Quanto da saída será impressa para o que o programa está fazendo, uma das opções: debug/info/warning/error/critical
--json                                     Exibir saída em formato JSON (legível por padrão).
--csv                                      Exibir saída em formato CSV (legível por padrão).

         

3. Configurações AMD-SMI

Com base na direção atual de desenvolvimento do ROCm, é possível que o amd-smi substitua o rocm-smi. Abaixo estão comandos comumente usados para o amd-smi: 

usage: amd-smi set [-h] -g GPU [GPU ...] [-f %] [-l LEVEL] [-P SETPROFILE] [-d SCLKMAX]
                   [-C PARTITION] [-M PARTITION] [-o WATTS] [-p POLICY_ID] [-x POLICY_ID]
                   [--json | --csv] [--file FILE] [--loglevel LEVEL]

Uma GPU deve ser especificada para definir uma configuração.                                  
Um argumento de configuração deve ser fornecido; múltiplos argumentos de configuração são aceitos.

Argumentos de Configuração:
-h, --help                                         mostrar esta mensagem de ajuda e sair
-g, --gpu GPU [GPU ...]                     Selecionar um ID de GPU, BDF ou UUID das opções disponíveis
-f, --fan %                                        Definir velocidade do ventilador da GPU (0-255 ou 0-100%)
-l, --perf-level NÍVEL                       Definir nível de performance
-P, --profile SETPROFILE                   Definir nível de perfil de potência (#) ou uma string de atributos de perfil personalizados
-d, --perf-determinism SCLKMAX      Definir limite de frequência do clock da GPU e nível de performance para obter mínima variação de performance
-C, --compute-partition PARTIÇÃO   Definir um dos seguintes modos de partição de computação: CPX, SPX, DPX, TPX, QPX
-M, --memory-partition PARTIÇÃO    Definir um dos seguintes modos de partição de memória: NPS1, NPS2, NPS4, NPS8
-o, --power-cap WATTS                     Definir limite de capacidade de potência
-p, --dpm-policy ID_POLÍTICA              Definir a política DPM da GPU usando o ID da política
-x, --xgmi-plpd ID_POLÍTICA               Definir a política de desligamento de energia por link do XGMI da GPU usando o ID da política

Modificadores de Comando:
--json                             Exibir saída em formato JSON (legível por padrão).
--csv                              Exibir saída em formato CSV (legível por padrão).
--file ARQUIVO                     Salvar saída em um arquivo no caminho fornecido (stdout por padrão).
--loglevel NÍVEL                   Definir o nível de log a partir das opções disponíveis: DEBUG, INFO, WARNING, ERROR, CRITICAL

  

Notas:  

Vale mencionar que algumas configurações falham ao usar amd-smi, mas funcionam com rocm-smi. Por exemplo: sudo amd-smi set -g 0 -f 90% falhou: "ValueError: Não foi possível definir a velocidade do ventilador 229 na GPU ID: 0 BDF:0000:03:00.0". Nesses casos, alterne para o uso do rocm-smi: sudo rocm-smi --setfan 90%. Funciona!

4. Suporte de Software para Configurações de Hardware

No Ubuntu, também estão disponíveis ferramentas de gerenciamento com interface gráfica. Embora não as abordemos em detalhes neste artigo, os usuários interessados podem explorar as seguintes opções:  

LACT: https://github.com/ilya-zlobintsev/LACT

radeon-profile: https://github.com/marazmista/radeon-profile

Ambiente de Desenvolvimento

Depois que seu hardware estiver configurado, você precisará configurar o seguinte ambiente em seu sistema para aceleração de GPU. Vamos continuar usando dispositivos AMD como exemplo:

• Suporte de Driver para Computação Acelerada: Precisamos instalar o driver amdgpu DKMS e o ROCm HIP SDK.
• Para bibliotecas Python que suportam computação acelerada: PyTorch compilado com ROCm. Se precisar de quantização para modelos, considere usar bitsandbytes (compilado com ROCm). Para computação acelerada, você pode precisar de flash-attention e triton (ambos compilados com ROCm). Durante o teste de inferência, você pode usar vllm. Em nosso exemplo, instalar PyTorch deve ser suficiente.

1. Instalação de Drivers e Dependências

Verifique se seu hardware e sistema são compatíveis com a versão mais recente do ROCm. Caso contrário, explore versões anteriores do ROCm. Se nenhuma versão for compatível com seu dispositivo, parabéns—você está finalmente livre do tormento da AMD! Considere explorar outras marcas. Se seu dispositivo for compatível com o ROCm, você tem duas opções: implantar o ambiente usando Docker ou instalar diretamente no host local. As etapas são semelhantes, seja instalando localmente ou dentro de um contêiner Docker. No entanto, recomendo fortemente o uso do Docker. Se você cometer erros durante as operações, basta excluir o contêiner e iniciar um novo a partir da imagem Ubuntu já baixada — sem necessidade de reinstalar o sistema! Portanto, este artigo foca na implantação do ambiente de desenvolvimento usando Docker. Ao instalar o Docker, use o Docker Engine (não o Docker Desktop). Consulte o guia de instalação: https://docs.docker.com/engine/install.

2. Baixar a Imagem Base

Baixe a imagem base do Ubuntu 22.04: docker pull ubuntu:22.04  

Notas:

Se preferir uma implantação não personalizada, baixe diretamente a imagem do ROCm/PyTorch: docker pull rocm/pytorch:latest.

Em seguida, execute o contêiner:

docker run -it --cap-add=SYS_PTRACE --security-opt seccomp=unconfined \
		--device=/dev/kfd --device=/dev/dri --group-add video \
		--ipc=host --network=host --shm-size 8G rocm/pytorch:latest

Dentro do contêiner Docker, a maioria dos ambientes de desenvolvimento já está configurada. Você pode copiar llm.c para dentro do contêiner ou cloná-lo do repositório oficial usando Git. Em seguida, vá diretamente para a seção de treinamento de modelo. No entanto, se encontrar problemas incomuns, você não saberá como resolvê-los. Portanto, minha recomendação é implantar passo a passo, para que você sempre saiba onde encontrar soluções.

3. Criar um Contêiner

Execute o seguinte comando para criar um contêiner (você pode escolher um nome diferente, se desejar):

docker run -it --name llmc --cap-add=SYS_PTRACE --ipc=host --network=host \
		--security-opt seccomp=unconfined --device=/dev/kfd --device=/dev/dri --group-add video ubuntu:22.04  

Notas:

"--name llmc" é opcional, nomeia o contêiner criado como "llmc". Se omitir este parâmetro, o contêiner terá um nome aleatório. Recomendo usar --network=host para simplificar o acesso de rede do contêiner ao host. Caso contrário, o modo de rede padrão é o modo bridge, o que complica o acesso à rede do contêiner para o host (por exemplo, acessar o proxy de rede do host). "--ipc=host permite que o contêiner compartilhe memória com o host, melhorando a eficiência. No entanto, isso reduz a segurança. Use conforme necessário. 

4. Instalação do Driver e Configuração do ROCm    

Instale as dependências de software necessárias. Se estiver instalando no host, prefixe os comandos com sudo:

apt install wget

apt install gpg

Configure o repositório APT do amdgpu:

wget https://repo.radeon.com/rocm/rocm.gpg.key -O - | gpg --dearmor | tee /etc/apt/keyrings/rocm.gpg > /dev/null  

echo "deb [arch=amd64 signed-by=/etc/apt/keyrings/rocm.gpg] https://repo.radeon.com/amdgpu/6.1.1/ubuntu jammy main" \    | tee /etc/apt/sources.list.d/amdgpu.list  

apt update  

echo "deb [arch=amd64 signed-by=/etc/apt/keyrings/rocm.gpg] https://repo.radeon.com/rocm/apt/6.1.1 jammy main" \    | tee --append /etc/apt/sources.list.d/rocm.list  

echo -e 'Package: *\nPin: release o=repo.radeon.com\nPin-Priority: 600' \    | tee /etc/apt/preferences.d/rocm-pin-600  

apt update  

Instale o driver amdgpu: 

apt install amdgpu-dkms

Se estiver instalando no host local, reinicie o sistema: reboot.

Instale o ROCm (escolhi o rocm-hip-sdk):  

apt install rocm-hip-sdk

Claro, você também tem outras opções:  

• rocm：Todos os pacotes, ferramentas e bibliotecas principais do ROCm.
• rocm-language-runtime：O runtime do ROCm.
• rocm-developer-tools：Depure e profile aplicativos HIP.
• rocm-hip-runtime：Execute aplicativos HIP escritos para a plataforma AMD.
• rocm-hip-runtime-devel：Desenvolva aplicativos no HIP ou faça a portabilidade do CUDA.
• rocm-opencl-runtime：Execute aplicativos baseados em OpenCL na plataforma AMD.
• rocm-opencl-sdk：Desenvolva aplicativos baseados em OpenCL para a plataforma AMD.
• rocm-hip-libraries：Bibliotecas HIP otimizadas para a plataforma AMD.
• rocm-hip-sdk：Desenvolva ou faça portabilidade de aplicativos e bibliotecas HIP para a plataforma AMD.
• rocm-ml-libraries：Principais bibliotecas de aprendizado de máquina. Inclui MIOpen.
• rocm-ml-sdk：Desenvolva e execute aplicativos de aprendizado de máquina para AMD.
• rocm-openmp-runtime：Execute aplicativos baseados em OpenMP na plataforma AMD.
• rocm-openmp-sdk：Desenvolva aplicativos baseados em OpenMP para o software AMD.

Após a instalação, adicione as seguintes variáveis de ambiente:  

tee --append /etc/ld.so.conf.d/rocm.conf <<EOF

/opt/rocm/lib/opt/rocm/lib64EOF  

ldconfig

Verifique o status do DKMS:

dkms status

Adicione os caminhos binários à variável de ambiente PATH:

export PATH=$PATH:/opt/rocm-6.1.1/bin

Verifique a instalação: /opt/rocm-6.1.1/bin/rocminfo /opt/rocm-6.1.1/bin/clinfo  

5. Instalando o PyTorch

Se o Python não estiver instalado, use apt para instalá-lo ou configure um ambiente Conda (Miniconda): apt install libjpeg-dev python3-dev python3-pip  

Em seguida, verifique o site oficial do PyTorch para ver se sua versão do ROCm é compatível. Até agora, a versão oficial não suporta o ROCm 6.1.1, então instalaremos a versão preview:  

pip3 install --pre torch torchvision torchaudio --index-url https://download.pytorch.org/whl/nightly/rocm6.1/ 

Se sua versão do ROCm for inferior à versão oficialmente suportada, ajuste o comando de instalação conforme necessário. Por exemplo, se o comando de lançamento oficial é: pip3 install torch --index-url https://download.pytorch.org/whl/rocm6.0, e sua versão do ROCm é "5.7.*", você pode instalar da seguinte maneira:  

pip3 install torch --index-url https://download.pytorch.org/whl/rocm5.7

Se você encontrar o problema "NameError: name ‘amdsmi’ is not defined", é porque as versões mais recentes do Torch requerem suporte ao Python para o amdsmi. Infelizmente, o uso direto do pip não funcionará. Será necessário compilar e instalar localmente. Navegue até /opt/rocm/share/amd_smi e instale amd-smi-lib:  

apt install amd-smi-lib  

Se você estiver instalando na versão padrão do Python do host:  

python3 -m pip install --user . 

Se encontrar um erro de permissão, como:  

error: Cannot update time stamp of directory 'amdsmi.egg-info'  

error: could not create 'amdsmi.egg-info': Permission denied  

Execute o seguinte comando com privilégios de root:  

sudo python3 -m pip install --user .  

Se o Python3 não for encontrado, use:  

sudo -H python3 -m pip install --user .  

Se você estiver usando um ambiente Conda (por exemplo, chamado "train_llm"), instale da seguinte maneira:  

sudo /home/deeper/miniconda/envs/train_llm/bin/python -m pip install . 

Substitua o caminho pelo caminho do Python do seu ambiente virtual específico.

Finalmente, tente novamente:  

pip3 install --pre torch torchvision torchaudio --index-url https://download.pytorch.org/whl/nightly/rocm6.1/

  

Treina o Modelo

Semelhante ao artigo anterior, continuaremos usando o projeto de código aberto "llm.c". Pessoalmente, acho esse projeto excelente—o código é claro e os comentários são detalhados, facilitando a leitura. Leitores interessados podem explorar todo o código-fonte desse projeto para obter uma visão clara de todo o processo de treinamento de grandes modelos de linguagem. Não vou reiterar o código para cada etapa de treinamento aqui, pois os comentários no código-fonte já são bastante explícitos.  

Para baixar o repositório "llm.c", observe que você não deve clonar o repositório oficial, mas usar o projeto "https://github.com/anthonix/llm.c" que suporta dispositivos AMD. Se você tiver problemas no treinamento, pode alternar para a versão do código-fonte que estou usando, a versão atual que estou utilizando é "37dfcf6":

cd llm.c
git checkout 37dfcf6

Se precisar trocar de versão, use a seguinte linha de comando após clonar o projeto:

1. Instale as dependências do projeto

Primeiro, instale as dependências do projeto:  

pip install -r requirements.txt 

Observe que você deve instalar o Torch primeiro antes de instalar as dependências de requirements.txt para evitar conflitos de versão.

Em seguida, compile o projeto:  

make train_gpt2amd AMDGPU_TARGETS=gfx1100 

Para determinar sua ISA (Arquitetura do Conjunto de Instruções) específica, use rocminfo e filtre a saída com grep:  

rocminfo | grep Name:  

2. Prepare-se para o treinamento

Esta etapa é semelhante ao treinamento em uma CPU, então não entrarei em detalhes aqui. Se precisar de uma explicação abrangente, consulte o artigo anterior. Abaixo está o comando de treinamento.

Obtenha os dados:

python data_enc

Prepare-se para o treinamento:

python train_gpt2.py --input_bin data/val_data.bin

 Substitua "data/val_data.bin" pelo caminho de saída ao executar data_enc.   

Execute o seguinte comando: 

make train_gpt2amd AMDGPU_TARGETS=gfx1100  

Novamente, substitua gfx1100 por sua ISA específica obtida com rocminfo.   

Nota:  

Se encontrar um "erro fatal: arquivo ‘cmath’ não encontrado", provavelmente é devido a uma versão incompatível do g++. Algumas versões do Ubuntu vêm com g++11, mas não com g++12. Instale o g++12 e defina-o como a versão padrão: 

apt install g++-12  

update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-12 60 --slave /usr/bin/g++ g++ /usr/bin/g++-12 

Ignore os "4 avisos gerados ao compilar para o host.", execute o seguinte comando:  

./train_gpt2amd  

Quando executei o último comando, recebi um erro de programa com "[CUDA ERROR] no arquivo build/hip/llmc/layernorm.cuh:400". Se você se arrepender de ter escolhido o hardware AMD neste ponto, acredite, isso é apenas o começo—muitos mais desafios aguardam. A jornada com hardware AMD está apenas começando!  

Se conseguir executar com sucesso, ótimo! Se não, não se desanime, ainda podemos usar scripts Python para treinar o modelo.   

Usando scripts python para treinar o modelo, você pode executar o seguinte comando:  

python train_gpt2.py \
    --input_bin "./data/train_data.bin" \
    --input_val_bin "./data/val_data.bin" \
    --val_loss_every 10 \
    --sample_every 0 \
    --output_dir pylog124M \
    --write_tensors 0 \
    --model d12 \
    --batch_size 16 \
    --sequence_length 128 \
    --total_batch_size 4096 \
    --dtype bfloat16 \
    --compile 1 \
    --tensorcores 1 \
    --flash 1 \
    --num_iterations 100 \
    --weight_decay 0.1 \
    --zero_stage 1 \
    --learning_rate 0.0006 \
    --warmup_iters 0 \
    --learning_rate_decay_frac 0.0 \
    --overfit_single_batch 0

Aqui estão alguns parâmetros que precisam ser mencionados:  

• –input_bin "./data/train_data.bin" Este é nosso conjunto de dados de treinamento;
• –input_val_bin "./data/val_data.bin" Este é nosso conjunto de dados de validação;
• –val_loss_every 10 Imprime a perda a cada certo número de etapas;
• –batch_size 16 Esse valor deve ser uma potência de 2, caso contrário, ocorrerá um erro. Como estamos apenas testando e o conjunto de dados não é grande, não há necessidade de ser muito grande;
• –sequence_length 128 Esse valor deve ser uma potência de 2, caso contrário, ocorrerá um erro. Como o comprimento da sequência do nosso conjunto de dados é 64, configurei para 128 aqui; 
• –total_batch_size 4096 Como estamos apenas testando, esse valor não precisa ser muito grande. Da mesma forma, esse valor deve ser uma potência de 2, caso contrário, ocorrerá um erro; 
• –num_iterations 100 Este é o número de etapas de treinamento. Da mesma forma, como é um teste, simplesmente configurei para 100;
• –flash 1 Esse valor indica se deve ativar a atenção flash, "1" é para ativar, "0" é para desativar. 
  

Os resultados de execução:

Como você pode ver, treinamos com sucesso um modelo de linguagem financeira exclusivo para nós usando a GPU. Agora vamos comparar com o tempo que usamos para treinar com CPU:  

  

Originalmente, nosso processo de treinamento com CPU levava em média cerca de 8000ms por etapa, enquanto o treinamento com GPU levou menos de 80ms por etapa.

Embora alguns parâmetros possam ter mudado um pouco, não é difícil ver pelo tempo de cada etapa de treinamento que usar GPU acelerará significativamente o processo de treinamento, quase 100 vezes mais rápido!  

Como nosso modelo é apenas um exemplo simples treinado e não foi otimizado, não é necessário criar uma estratégia EA para teste, pois podemos imaginar que o resultado deve ser muito ruim.

Mas não se preocupe, os próximos artigos discutirão como ajustar finamente um grande modelo de linguagem usando nossos próprios dados e, em seguida, criar uma EA e testá-la.  

Notas:  

Se nesta parte ocorrer um erro RuntimeError: erro HIP: a operação não pode ser realizada no estado atual. Compile com TORCH_USE_HIP_DSA para ativar as afirmações do lado do dispositivo.  

Tente adicionar variáveis de ambiente:  

export HSA_OVERRIDE_GFX_VERSION=11.0.0

export HIP_VISIBLE_DEVICES=0

export ROCM_PATH=/opt/rocm

export AMDGPU_TARGETS=gfx1100

Ou adicione o seguinte código no início de train_gpt2.py:  

from os import putenv

putenv(“HSA_OVERRIDE_GFX_VERSION”, “11.0.0”)  

Onde 11.0.0 é o HSA do 7900xtx, você precisa verificar o HSA de acordo com seu próprio dispositivo e alterá-lo para o valor apropriado. O gfx1100 é a ISA do 7900xtx, você precisa mudar para o valor apropriado de acordo com seu próprio hardware.  

Resumo

Neste artigo, discutimos como treinar um grande modelo de linguagem exclusivo para nós em uma placa gráfica usando nosso próprio conjunto de dados projetado. Claro, também discutimos a configuração do ambiente de desenvolvimento em computação acelerada com placas gráficas AMD, complementamos a parte que não foi mencionada na segunda parte desta série e também concluímos a configuração do ambiente das duas principais placas gráficas (AMD e Nvidia) no mercado atual para computação acelerada.  

Mas como este exemplo de demonstração não foi otimizado, também não avaliamos o modelo, nem formulamos uma estratégia EA baseada no modelo e a testamos no cliente MetaTrader, pois no momento este modelo de demonstração está apenas na fase de pré-treinamento, então essas operações são desnecessárias e não atingiram um nível prático. Nos próximos artigos, discutiremos o ajuste fino de grandes modelos de linguagem e formularemos estratégias EA correspondentes para testá-las no cliente MetaTrader.  

Nos vemos no nosso próximo artigo!