# Pré-treinamento contínuo (CPT)
O pré-treinamento contínuo (CPT) é uma técnica de treinamento que estende a fase de pré-treinamento de um modelo de base, expondo-o a texto adicional sem rótulo de domínios ou corpora específicos. Ao contrário do ajuste fino supervisionado, que requer pares de entrada-saída rotulados, o CPT treina em documentos brutos para ajudar o modelo a adquirir um conhecimento mais profundo de novos domínios, aprender a terminologia e os padrões de escrita específicos do domínio e se adaptar a determinados tipos de conteúdo ou áreas temáticas.
Essa abordagem é particularmente valiosa quando você tem grandes volumes (dezenas de bilhões de tokens) de dados de texto específicos do domínio, como documentos legais, literatura médica, documentação técnica ou conteúdo comercial proprietário, e deseja que o modelo desenvolva fluência nativa nesse domínio. Geralmente, após a etapa do CPT, o modelo precisa passar por etapas adicionais de ajuste de instruções para permitir que o modelo use o conhecimento recém-adquirido e conclua tarefas úteis.
**Modelos compatíveis**
O CPT está disponível para os seguintes modelos do Amazon Nova:
+ Nova 1.0 (Micro, Lite, Pro)
+ Nova 2.0 (Lite)
**Quando usar o Nova 1.0 versus o Nova 2.0**
A família de modelos do Amazon Nova oferece vários pontos operacionais de relação preço/performance para otimizar entre precisão, velocidade e custo.
Escolha o Nova 2.0 quando você precisar do seguinte:
+ Recursos avançados de raciocínio para tarefas analíticas complexas
+ Desempenho superior em codificação, matemática e resolução de problemas científicos
+ Suporte a janelas de contexto mais longas
+ Melhor desempenho multilíngue
**nota**
O modelo maior nem sempre é melhor. Considere a relação custo-performance e seus requisitos comerciais específicos ao escolher entre os modelos Nova 1.0 e Nova 2.0.
# CPT no Nova 2.0
O Amazon Nova Lite 2.0 é um modelo de raciocínio treinado em um conjunto de dados maior e mais diversificado do que o Nova Lite 1.0. Apesar de ser um modelo maior, o Nova Lite 2.0 oferece inferência mais rápida do que o Nova Lite 1.0, ao mesmo tempo em que oferece recursos aprimorados de raciocínio, janelas de contexto mais longas e melhor desempenho multilíngue.
O CPT no Nova 2.0 permite que você estenda esses recursos avançados com seus dados específicos de domínio, permitindo que o modelo desenvolva uma profunda experiência em áreas especializadas, mantendo suas habilidades superiores de raciocínio e análise.
## Exemplo de fórmula de CPT
Confira a seguir um exemplo de fórmula de CPT. Você pode encontrar essa fórmula e outras no repositório de [fórmulas](https://github.com/aws/sagemaker-hyperpod-recipes/tree/main/recipes_collection/recipes/training/nova).
```
# Note:
# This recipe can run on p5.48xlarge
# Run config
run:
name: "my-cpt-run" # A descriptive name for your training job
model_type: "amazon.nova-2-lite-v1:0:256k" # Model variant specification, do not change
model_name_or_path: "nova-lite-2/prod" # Base model path, do not change
replicas: 8 # Number of compute instances for training, allowed values are 4, 8, 16, 32
data_s3_path: "" # Customer data paths
validation_data_s3_path: "" # Customer validation data paths
output_s3_path: "" # Output artifact path, job-specific configuration - not compatible with standard SageMaker Training Jobs
mlflow_tracking_uri: "" # Required for MLFlow
mlflow_experiment_name: "my-cpt-experiment" # Optional for MLFlow. Note: leave this field non-empty
mlflow_run_name: "my-cpt-run" # Optional for MLFlow. Note: leave this field non-empty
## Training specific configs
training_config:
task_type: cpt
max_length: 8192 # Maximum context window size (tokens)
global_batch_size: 256 # Global batch size, allowed values are 32, 64, 128, 256.
trainer:
max_steps: 10 # The number of training steps to run total
val_check_interval: 10 # The number of steps between running validation. Integer count or float percentage
limit_val_batches: 2 # Batches of the validation set to use each trigger
model:
hidden_dropout: 0.0 # Dropout for hidden states, must be between 0.0 and 1.0
attention_dropout: 0.0 # Dropout for attention weights, must be between 0.0 and 1.0
optim:
optimizer: adam
lr: 1e-5 # Learning rate
name: distributed_fused_adam # Optimizer algorithm, do not change
adam_w_mode: true # Enable AdamW mode
eps: 1e-06 # Epsilon for numerical stability
weight_decay: 0.0 # L2 regularization strength, must be between 0.0 and 1.0
adam_beta1: 0.9 # Beta1 for Adam optimizer
adam_beta2: 0.95 # Beta2 for Adam optimizer
sched:
warmup_steps: 10 # Learning rate warmup steps
constant_steps: 0 # Steps at constant learning rate
min_lr: 1e-6 # Minimum learning rate, must be lower than lr
```
## Preparação de dados para CPT no 2.0
**Requisitos de formato de dados**
Os conjuntos de dados de treinamento e validação devem ser arquivos JSONL seguindo o formato mostrado abaixo, em que cada linha contém um objeto JSON representando uma conversa com a estrutura e os campos necessários. Aqui está um exemplo:
```
{"text": "AWS stands for Amazon Web Services"}
{"text": "Amazon SageMaker is a fully managed machine learning service"}
{"text": "Amazon Bedrock is a fully managed service for foundation models"}
```
As entradas de texto devem ter um conteúdo de alta qualidade que flua naturalmente e represente seu domínio de destino.
Teste se os dados podem ser convertidos no [formato Arrow](https://huggingface.co/docs/datasets/en/about_arrow). Use o script Python abaixo para ajudar com essa ação. Certifique-se de que, no mínimo, a versão `datasets==2.18.0` seja usada:
```
from datasets import load_dataset, load_from_disk
from pathlib import Path
input_path = Path("")
output_path = Path("")
dataset = load_dataset("json", data_files=str(input_path), split="train")
dataset.save_to_disk(str(output_path), max_shard_size="1GB")
try:
test_dataset = datasets.load_from_disk(output_dir)
print(f"Dataset loaded successfully ✅! Contains {len(test_dataset)} samples")
except Exception as e:
print(e)
```
Ele deve imprimir o mesmo número de linhas que estavam no arquivo JSONL.
Ao usar o datamixing, execute a primeira tarefa com `max_steps=2`. Isso ajudará a criar otimizações no cluster para acesso aos dados e a validar se todos os datamixes estão disponíveis.
**Como preparar dados para o CPT**
Os dados de treinamento são o fator determinante mais importante para o sucesso do pré-treinamento contínuo. Embora os dados do CPT sejam frequentemente descritos como “sem rótulo”, a realidade é muito mais sutil. A forma como os dados são estruturados, formatados e apresentados determina se o modelo vai adquirir o conhecimento e as habilidades necessárias para o caso de uso do negócio.
### Preparação de conjuntos de dados empresariais estruturados para CPT
É um desafio comum para empresas e organizações que criam modelos de base especializados em seu domínio. A maioria das empresas possui repositórios robustos de dados estruturados: catálogos de produtos, perfis de usuários, logs de transações, envios de formulários, chamadas de API e metadados operacionais. À primeira vista, isso parece ser muito diferente em relação aos textos não estruturados da web, comumente utilizados no pré-treinamento padrão.
Para aprender de forma eficaz com dados empresariais estruturados, pense cuidadosamente nas tarefas downstream e projete a apresentação dos dados para forçar o modelo a aprender as relações preditivas corretas.
Para o aproveitamento total do potencial do pré-treinamento contínuo, considere:
+ Quais tarefas o modelo deve realizar no momento da inferência
+ Quais informações estão presentes nos dados brutos
+ Como estruturar esses dados para que o modelo aprenda a extrair e manipular as informações corretamente
Simplesmente despejar dados estruturados no treinamento não ensinará o modelo a raciocinar sobre isso. Molde ativamente a apresentação dos dados para orientar o que o modelo aprende.
Nas seções a seguir, há uma revisão da literatura que demonstra a importância do aumento de dados e fornece exemplos de estratégias de aumento para dados comerciais estruturados que fornecerão ideias úteis sobre como tratar e organizar o conjunto de dados de negócios para o CPT.
**Dados estruturados para o CPT na literatura**
O CPT pode incluir fatos de domínio no modelo, mas geralmente falha em tornar esses fatos recuperáveis e manipuláveis quando as entradas ou tarefas mudam. Experimentos controlados mostram que, sem um aumento diverso durante o pré-treinamento, os modelos memorizam fatos de maneiras frágeis que permanecem difíceis de extrair mesmo após o ajuste posterior das instruções, e recomendam injetar sinais semelhantes a instruções no início do treinamento. Para dados semiestruturados, a serialização randomizada e outros aumentos reduzem o sobreajuste do esquema, e é por isso que o CPT deve ser intercalado com tarefas de estilo de instrução em vez de ser executado primeiro e o IFT depois. Trabalhos com foco em finanças indicam que a combinação conjunta de dados de CPT e de instrução no momento do lote promove a melhoria da generalização e a redução do esquecimento em comparação ao método sequencial. O relatório técnico da Qwen converge para o mesmo padrão ao integrar dados de instrução de alta qualidade ao próprio pré-treinamento, o que aumenta o aprendizado contextual e preserva o acompanhamento das instruções enquanto adquire novos conhecimentos de domínio.
O aumento de dados para corpora semiestruturadas é uma alavanca fundamental. O CPT com reconhecimento de gráficos sintéticos expande pequenos conjuntos de domínios em corpora vinculados a entidades que ensinam explicitamente relações e compostos com recuperação em tempo de inferência. A combinação conjunta de CPT e instruções apresenta desempenho superior a pipelines sequenciais em finanças, e o equilíbrio entre dados de domínio e dados gerais promove a redução da degradação de habilidades gerais. O CPT de domínio de altíssima escala também pode manter uma ampla capacidade e até mesmo permitir compensações por meio da mesclagem de modelos, mas ainda aponta o ajuste de instruções como uma próxima etapa essencial, reforçando o valor da introdução de sinais de instrução durante o CPT.
**Injeção de diversidade por meio de randomização e embaralhamento**
Uma estratégia geral que ajuda a ensinar o modelo de forma eficaz dos conjuntos de dados estruturados e semiestruturados é alterar a ordem dos campos nos conjuntos de dados e também excluir de forma randomizada algumas chaves.
Embaralhar os campos força o modelo a ler o que cada valor significa em vez de onde ele aparece e a aprender as relações entre todos os campos. Por exemplo, no caso de um videogame publicado na loja da Amazon, em que “Título”, “Plataforma”, “Preço”, “Condição” e “Edição” apresentam ordens variadas, o modelo fica impedido de utilizar a dependência posicional, como a suposição de que a “terceira posição corresponde à plataforma”; ele deve vincular rótulos a valores e aprender as relações bilaterais entre atributos: título ⇄ plataforma, plataforma ⇄ preço, condição ⇄ preço. Assim, ele pode, por exemplo, inferir uma plataforma provável do nome de um jogo e de um preço observado, ou estimar uma faixa de preço plausível considerando um título e uma plataforma.
O descarte randomizado de chaves durante a serialização atua como um descarte de recursos: evita a coadaptação em qualquer campo e força o modelo a recuperar as informações perdidas das evidências restantes. Se “Plataforma” estiver ausente, o modelo deverá retirá-la da string de título ou do texto de compatibilidade; se “Preço” estiver oculto, ele deverá triangular da plataforma, edição e condição. Essa abordagem cria simetria (A → B e B → A), robustez diante de listagens confusas do mundo real e invariância de esquema quando os campos estão ausentes, renomeados ou reordenados.
Um exemplo de estilo de compra torna isso concreto. Serialize o mesmo item de várias maneiras (“Título: ‘Elden Ring’ \$1 Plataforma: PlayStation 5 \$1 Condição: Usado - Como novo \$1 Preço: USD 34,99” e uma permutação como “Preço: USD 34,99 \$1 Título: ‘Elden Ring’ \$1 Condição: Usado - Como novo \$1 Plataforma: PlayStation 5”) e, em certas iterações, omita “Plataforma” deixando “Compatível com PS5” na descrição. Treine objetivos complementares, como predição da plataforma de \$1title, price\$1 e estimativa de um bucket de preços de \$1title, platform\$1. Como a ordem e até mesmo a presença das chaves variam, a única estratégia estável é aprender as verdadeiras relações entre os atributos em vez de memorizar um modelo.
### A forma como os dados são apresentados é importante
O aprendizado de LLMs ocorre por meio da predição do próximo token com base no conteúdo previamente processado. Portanto, a ordem dos campos e eventos mostrados durante o treinamento decide o que o modelo pode aprender. Se o formato do treinamento corresponder à tarefa real, a perda incidirá sobre os tokens de decisão exatos. Se os campos forem agrupados sem estrutura, o modelo aprenderá atalhos ou memorizará a popularidade e, em seguida, falhará quando solicitado a escolher entre as opções.
Mostre primeiro a situação, depois as opções e então a decisão. Se o modelo também precisar aprender sobre resultados ou explicações, coloque-os após a decisão.
### Exemplos de empacotamento de dados para o CPT
**O que é empacotamento de dados?**
Significa simplesmente preencher cada janela de sequência nos dados de treinamento com vários exemplos completos para que a janela fique densa com tokens reais, não com preenchimento.
**Por que isso importa?**
Durante o treinamento, um tamanho máximo de contexto é definido, por exemplo, 8.192 tokens. Os lotes são moldados para [tamanho do lote × extensão do contexto]. Se um exemplo de treinamento for menor que a extensão do contexto, as posições restantes serão preenchidas. O preenchimento mantém a execução via kernels de atenção e MLP, ainda que haja o mascaramento da função de perda, então a computação é paga por tokens que não transmitem nenhum sinal de aprendizado.
**Como realizar o empacotamento de dados?**
Para empacotar várias amostras, concatene vários exemplos de treinamento com um separador ` [DOC] ` entre eles (observe o espaço antes e depois do [DOC]) de forma que a extensão total dos exemplos permaneça abaixo da extensão de contexto desejada.
Um exemplo de documento empacotado seria assim:
```
{"text": "training sample 1 [DOC] training sample 2 [DOC] training sample 3"}
```
### Parâmetros de ajuste do CTP
Os parâmetros que estão disponíveis para ajuste com o CPT incluem:
**Configuração da execução**
+ **name**: um nome descritivo para a tarefa de treinamento. Isso ajuda a identificar sua tarefa no Console de Gerenciamento da AWS.
+ **model\$1type**: a variante do modelo do Amazon Nova a ser usada. As opções disponíveis são `amazon.nova-2-lite-v1:0:256k`.
+ **model\$1name\$1or\$1path**: o caminho para o modelo de base a ser usado em seu treinamento. As opções disponíveis são `nova-lite-2/prod` ou o caminho do S3 para o ponto de verificação pós-treinamento (`s3://customer-escrow-bucket-unique_id/training_run_name`).
+ **replicas**: o número de instâncias de computação a serem usadas no treinamento distribuído. Os valores disponíveis variam de acordo com o modelo escolhido. O Amazon Nova Lite 2.0 é compatível com 4, 8, 16 ou 32 réplicas.
+ **data\$1s3\$1path**: o local no S3 do conjunto de dados de treinamento, que é um arquivo JSONL. Esse arquivo deve residir na mesma conta e região da AWS que o cluster. Todos os locais do S3 fornecidos devem estar na mesma conta e região.
+ **validation\$1data\$1s3\$1path**: (opcional) o local no S3 do conjunto de dados de validação, que é um arquivo JSONL. Esse arquivo deve estar na mesma conta e região que o cluster. Todos os locais do S3 fornecidos devem estar na mesma conta e região.
+ **output\$1s3\$1path**: o local do S3 onde o manifesto e os logs do TensorBoard são armazenados. Todos os locais do S3 fornecidos devem estar na mesma conta da AWS e região da AWS.
+ **mlflow\$1tracking\$1uri**: o ARN da aplicação MLFlow a ser usada para registro em log do MLFlow
+ **mlflow\$1experiment\$1name**: nome do experimento do MLFlow
+ **mlflow\$1run\$1name**: nome de execução do MLFlow
**Configuração do treinamento**
+ **max\$1length**: o tamanho máximo da sequência em tokens. Isso determina o tamanho da janela de contexto para treinamento. O valor máximo permitido é 8.192 tokens para CPT.
Sequências mais longas melhorarão a eficiência do treinamento à custa de maiores requisitos de memória. Recomendamos que você faça a correspondência do parâmetro max\$1length com sua distribuição de dados.
+ **global\$1batch\$1size**: o número total de exemplos de treinamento processados juntos em uma única etapa de propagação (forward ou backward) em todos os dispositivos e operadores.
Esse valor multiplica o tamanho do lote por dispositivo e o número de dispositivos. Isso afeta a estabilidade do treinamento e o throughput. Recomendamos que você comece com um tamanho de lote que caiba confortavelmente na memória e possa ter a escala aumentada verticalmente a partir daí. Para dados específicos do domínio, lotes maiores podem suavizar demais os gradientes.
**Configurações do Trainer**
+ **max\$1steps**: o número de etapas de treinamento a serem executadas. Cada etapa treinará o modelo com o número de elementos `global_batch_size`
**Configurações do modelo**
+ **hidden\$1dropout**: a probabilidade de descartar saídas de estados ocultos. Aumente esse valor em aproximadamente 0,0-0,2 para reduzir o sobreajuste em conjuntos de dados menores. Os valores válidos estão entre 0 e 1, inclusive.
+ **attention\$1dropout**: a probabilidade de descartar pesos de atenção. Esse parâmetro pode ajudar na generalização. Os valores válidos estão entre 0 e 1, inclusive.
**Configuração do otimizador**
+ **lr**: a taxa de aprendizado, que controla o tamanho da etapa durante a otimização. Recomendamos valores entre 1e-6 e 1e-4 para um obter bom desempenho. Os valores válidos estão entre 0 e 1, inclusive.
+ **name**: o algoritmo otimizador. No momento, só há compatibilidade com `distributed_fused_adam`.
+ **weight\$1decay**: a força de regularização de L2. Valores mais altos (entre 0,01 e 0,1) aumentam a regularização.
+ **warmup\$1steps**: o número de etapas para aumentar gradualmente a taxa de aprendizado. Isso melhora a estabilidade do treinamento. Os valores válidos estão entre 1 e 20, inclusive.
+ **min\$1lr**: a taxa mínima de aprendizado ao término do decaimento. Os valores válidos estão entre 0-1, inclusive, mas devem ser menores que a taxa de aprendizado.