Destilação Amazon Nova

Este guia de início rápido ajuda você a começar a usar o modelo de destilação Amazon Nova usando o ajuste fino supervisionado (SFT) em IA. SageMaker

Conceitos

A destilação de modelos é um método que transfere conhecimento de modelos grandes e avançados para modelos menores e eficientes. Com os modelos do Amazon Nova, um modelo maior "instrutor" (como o Amazon Nova Pro ou o Amazon Nova Premier) transfere suas habilidades para um modelo menor "aprendiz" (como o Amazon Nova Lite ou o Amazon Nova Micro). Isso cria um modelo personalizado que mantém a alta performance usando menos recursos.

Componentes principais

O processo de destilação envolve principalmente dois tipos de modelos:

Os modelos de professores servem como fonte de conhecimento e incluem:

• Amazon Nova Pro (amazonas). nova-pro-v1:0)

• Amazon Nova Premier (Amazonas). nova-premier-v1:0)

Os modelos estudantis recebem e implementam o conhecimento:

• Amazon Nova Lite (amazonas). nova-lite-v(1:0:300 k)

• Amazon Nova Micro (amazonas. nova-micro-v(1:0:128 k)

• Amazon Nova Pro (amazonas). nova-pro-v1:0:300 k) - Disponível somente ao usar o Amazon Nova Premier como professor

Casos de uso

O modo de destilação é particularmente benéfico quando:

• Seu aplicativo tem requisitos rígidos de latência, custo e precisão.

• Você precisa de um modelo personalizado para tarefas específicas, mas não tem dados de treinamento rotulados de alta qualidade suficientes.

• Você deseja igualar o desempenho dos modelos avançados e, ao mesmo tempo, manter a eficiência dos modelos menores.

Pré-requisitos

• Conta da AWS com acesso aos modelos Amazon Nova e cotas de serviço apropriadas (mínimo de 6 instâncias P5 e 1 R5).

• Função do IAM com permissões para trabalhos SageMaker de treinamento.

• Bucket Amazon S3 para armazenar dados e resultados de treinamento.

Configuração de aumento de dados

A fase de aumento de dados usa trabalhos de SageMaker treinamento para gerar dados de treinamento de alta qualidade usando o modelo do professor. Esta seção detalha o processo de configuração e os requisitos.

Perfil do IAM

Para criar funções do IAM e anexar políticas, consulte Criação de funções e anexação de políticas (console). Se você usar AWS CLI, siga as instruções em create-role e. attach-role-policy Para obter mais informações, consulte Como usar as funções de execução de SageMaker IA no Guia do desenvolvedor de SageMaker IA.

A seguir estão exemplos de comandos para sua referência.

Crie uma função de execução de SageMaker IA

A função é criada com uma relação de confiança que permite que a SageMaker IA, Amazon Bedrock, assuma essa função. Isso permite que esses serviços atuem em seu nome ao executar trabalhos de inferência em lote.

aws iam create-role \
 --role-name NovaCustomizationRole \
 --assume-role-policy-document '{
 "Version": "2012-10-17",
 "Statement": [
 {
 "Effect": "Allow",
 "Principal": {
 "Service": ["sagemaker.amazonaws.com",
            "bedrock.amazonaws.com"]
 },
 "Action": "sts:AssumeRole"
 }
 ]
}'               

Anexe as políticas necessárias

# Attach AmazonSageMakerFullAccess
 aws iam attach-role-policy \
 --role-name NovaCustomizationRole \
 --policy-arn arn:aws:iam::aws:policy/AmazonSageMakerFullAccess

# Attach AmazonBedrockFullAccess
 aws iam attach-role-policy \
 --role-name NovaCustomizationRole \
 --policy-arn arn:aws:iam::aws:policy/AmazonBedrockFullAccess

 # Attach S3 access policy
 aws iam attach-role-policy \
 --role-name NovaCustomizationRole \
 --policy-arn arn:aws:iam::aws:policy/AmazonS3FullAccess
 
# Attach AmazonEC2FullAccess
 aws iam attach-role-policy \
 --role-name NovaCustomizationRole \
 --policy-arn arn:aws:iam::aws:policy/AmazonEC2FullAccess
 
# Attach AmazonEC2ContainerRegistryFullAccess
 aws iam attach-role-policy \
 --role-name NovaCustomizationRole \
 --policy-arn arn:aws:iam::aws:policy/AmazonEC2ContainerRegistryFullAccess
 
# Attach AmazonEC2ContainerRegistryFullAccess
 aws iam attach-role-policy \
 --role-name NovaCustomizationRole \
 --policy-arn arn:aws:iam::aws:policy/CloudWatchLogsFullAccess 

Anexe a seguinte política em linha à função de execução do cliente necessária para o Distillation Container.

• AWS KMS permissões: permite que a função interaja com o AWS Key Management Service, necessário para acessar recursos criptografados ou gerenciar chaves de criptografia.

• IAM:PassRole: essa permissão geralmente é necessária quando um serviço precisa passar essa função para outro serviço, um padrão comum em integrações AWS de serviços.

aws iam put-role-policy \
 --role-name NovaCustomizationRole \
 --policy-name Distillation-Additional-Permissions\
 --policy-document '{
 "Version": "2012-10-17",
 "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "kms:*"
            ],
            "Resource": "*"
        },
        {
            "Effect": "Allow",
            "Action": [
                "iam:PassRole"
            ],
            "Resource": "*"
        }
    ]
}

Configuração da Amazon VPC

Para criar a configuração da Amazon VPC para trabalhos de treinamento de SageMaker IA usando o AWS Management Console, siga as instruções em Configurar sua VPC privada para SageMaker treinamento (console).

Crie uma nova Amazon VPC

Name: Distillation-VPC
IPv4 CIDR: 10.0.0.0/16 (or your preferred range)
Availability Zones: 2
Public Subnets: 2
Private Subnets: 2
NAT Gateways: 1 (in one AZ)

Crie um grupo de segurança

Name: Distillation-SG
Description: Security group for data distillation jobs
Inbound Rules: Allow all traffic from self
Outbound Rules: Allow all traffic (0.0.0.0/0)

Crie endpoints VPC para os seguintes serviços

com.amazonaws.[region].s3
com.amazonaws.[region].sagemaker.api
com.amazonaws.[region].sagemaker.runtime
com.amazonaws.[region].bedrock.api
com.amazonaws.[region].bedrock.runtime
com.amazonaws.[region].sts
com.amazonaws.[region].logs
com.amazonaws.[region].ecr.api
com.amazonaws.[region].ecr.dkr

Para cada endpoint:

• Selecione sua destilação-VPC

• Escolha as sub-redes privadas

• Selecione o grupo de segurança Distillation-SG

AWS KMS chaves

Ao trabalhar com a inferência em lote do Amazon Bedrock, é necessária uma AWS KMS chave para segurança e conformidade dos dados. Os trabalhos de inferência em lote do Amazon Bedrock exigem que os buckets de entrada e saída do Amazon S3 sejam criptografados AWS KMS com chaves para garantir a proteção de dados em repouso.

Crie uma chave KMS usando AWS CLI este comando:

# Create KMS key
aws kms create-key \
--description "KMS key for Amazon Bedrock batch inference Amazon S3 bucket" \
--region us-east-1

O comando exibirá as principais informações, incluindo o ARN. Resultado do exemplo:

{
    "KeyMetadata": {
        "KeyId": "1234abcd-12ab-34cd-56ef-1234567890ab",
        "Arn": "arn:aws:kms:us-east-1:111122223333:key/1234abcd-12ab-34cd-56ef-1234567890ab"
    }
}

nota

Salve o ARN da chave KMS da saída, pois você precisará dele para a criação do bucket do Amazon S3 na próxima seção.

Bucket do Amazon S3

Você precisa de dois tipos de armazenamento no Amazon S3. O bucket Amazon S3 gerenciado pelo cliente armazena seus dados de entrada e arquivos de saída. manifest.json Você cria e gerencia esse bucket e pode usar um único bucket para entrada e saída. Esse bucket deve ser configurado com criptografia KMS, pois armazenará dados de saída confidenciais e será usado por trabalhos de inferência em lote do Amazon Bedrock. O Amazon Bedrock exige buckets criptografados por KMS para processar tarefas de inferência em lote.

O bucket Amazon S3 gerenciado por serviços armazena os pesos do modelo. Um bucket Amazon S3 gerenciado por serviços é criado automaticamente durante seu primeiro trabalho de treinamento. Ele tem controles de acesso restritos com caminhos específicos acessíveis somente por meio de arquivos de manifesto.

Para criar um bucket em um específico Região da AWS, use o comando da CLI create-bucket.

Exemplo de comando para criar um bucket Amazon S3 com AWS KMS criptografia. {kms_key_arn}Substitua pelo ARN da sua AWS KMS chave. Você precisará criar uma AWS KMS chave primeiro, caso ainda não tenha feito isso.

aws s3api create-bucket \
--bucket {my_bucket_name} \
--region {aws_region} \
--create-bucket-configuration LocationConstraint={aws_region} \
--server-side-encryption-configuration '{
    "Rules": [
        {
            "ApplyServerSideEncryptionByDefault": {
                "SSEAlgorithm": "aws:kms",
                "KMSMasterKeyID": "{kms_key_arn}"
            },
            "BucketKeyEnabled": true
        }
    ]
}'

Comece um trabalho SageMaker de treinamento

Antes de começar um trabalho de treinamento, prepare seus dados.

Requisito de formato de dados - Seu conjunto de dados de entrada deve estar no formato JSONL, com cada linha contendo uma amostra no formato inverso. Para obter mais informações, siga Preparando dados para destilar modelos de compreensão.

Restrições do conjunto de dados

• Solicitações mínimas: 100

• Tamanho máximo do arquivo: 2GB

• Comprimento máximo da linha: 180KB

• Formato de arquivo: somente JSONL

Para fazer upload dos dados de entrada, execute o comando a seguir.

aws s3 cp /path/to/input-data/ s3://customer-input-data-bucket/ —recursive

Receita de aumento de dados

Você pode obter a receita de destilação no repositório de receitas. SageMaker HyperPod A receita de destilação está no diretório:. recipes-collection/recipes/fine-tuning/nova O processo de aumento de dados é controlado por um arquivo de configuração YAML. Abaixo está uma explicação detalhada de cada parâmetro. Todos são campos obrigatórios.

Parameter	Descrição
nome	Um nome descritivo para seu trabalho de treinamento. Isso ajuda a identificar seu trabalho no AWS Management Console.
dados_de_destilação	Ativa o trabalho de destilação de dados, não modifique esse campo.
maxNumberOfSolicitações	O número máximo de solicitações no conjunto de dados.
maxResponseLength	O comprimento máximo de resposta por solicitação (tokens).
maxInputFileSizeInGB	O tamanho máximo do arquivo de entrada (em GB).
maxLineLengthEm KB	O tamanho máximo de uma única linha no arquivo de entrada (em KB).
maxStudentModelFineTuningContextLengthInTokens	O tamanho máximo da janela de contexto (tokens) para o modelo do aluno. O valor é não deve exceder a capacidade do modelo estudantil. Você pode definir esse valor como 32k ou 64k com base na capacidade do modelo do aluno.
teacherModelId	Ao definir o ID do modelo do professor, selecione entre dois: Para Amazon Titan Premier: “us.amazon. nova-premier-v1:0 "para a região do IAD. Nota: Isso só está disponível na região IAD. Para o Amazon Nova Pro: “us.amazon. nova-pro-v1:0 "para a região IAD e “eu.amazon”. nova-pro-v1:0 "para a região ARN.
temperature	Controla a aleatoriedade da resposta (0,7 recomendado para equilíbrio).
top_p	Limite de probabilidade cumulativa para amostragem de tokens (0,9 é recomendado).
balde do cliente	Bucket Amazon S3 para input/output dados.
kms_key	AWS KMS chave para criptografar a saída no S3, isso é necessário para a inferência em lote do Bedrock para armazenar a saída retornada pelo trabalho de inferência.

Limitação

Para Teacher Model como Nova Premier - Compatível apenas com a região IAD (us-east-1), pois a inferência em lote do Amazon Bedrock não está disponível na região ARN (). eu-north-1

Melhores práticas

Preparação de dados

• Inclua 100 exemplos rotulados de alta qualidade para orientar o modelo do professor

• Remova rótulos de baixa qualidade antes do envio

• Siga as melhores práticas recomendadas de compreensão de texto

• Prompts de teste com o modelo do professor antes de iniciar a destilação

Seleção de modelos

• Use o Nova Pro como professor para casos de uso geral

• Considere o Nova Premier para obter conhecimento especializado do domínio

• Escolha o modelo de estudante com base nos requisitos de latência e custo

Otimização de desempenho

• Comece com a temperatura recomendada (0,7) e top_p (0,9)

• Valide a qualidade aumentada dos dados antes de fazer o ajuste fino

• Siga as diretrizes em Seleção de hiperparâmetros para ajustar os hiperparâmetros

Começando um trabalho com o PySDK

O exemplo de caderno a seguir demonstra como executar um trabalho de SageMaker treinamento para destilação. Para obter mais informações, consulte Usar um estimador de SageMaker IA para executar um trabalho de treinamento.

import os
import sagemaker,boto3
from sagemaker.pytorch import PyTorch
from sagemaker.inputs import TrainingInput

sagemaker_session = sagemaker.Session()
role = sagemaker.get_execution_role()

# SETUP
job_name = <Your_job_name> # Must be unique for every run

input_s3_uri = <S3 URI to your input dataset> # Must end in .jsonl file
output_s3_uri = <S3 URI to your output bucket> + job_name

image_uri = "708977205387.dkr.ecr.us-east-1.amazonaws.com/nova-distillation-repo:SM-TJ-DISTILL-LATEST" # Do not change
instance_type = "ml.r5.4xlarge" # Recommedation is to use cpu instances 
instance_count = 1 # Must be 1, do not change 
role_arn = <IAM role to execute the job with>
recipe_path = <Local path to your recipe>

# Execution

estimator = PyTorch(
    output_path=output_s3_uri,
    base_job_name=job_name,
    role=role_arn,
    instance_count=instance_count,
    instance_type=instance_type,
    training_recipe=recipe_path,
    max_run=432000,
    sagemaker_session=sagemaker_session,
    image_uri=image_uri,
    subnets= ['subnet-xxxxxxxxxxxxxxxxx','subnet-xxxxxxxxxxxxxxxxx'], # Add subnet groups created in previous steps
    security_group_ids= ['sg-xxxxxxxxxxxxxxxxx'], # Add security group created in previous steps
    disable_profiler=True,
    debugger_hook_config=False
)

trainingInput = TrainingInput(
    s3_data=input_s3_uri,
    distribution='FullyReplicated',
    s3_data_type='Converse'
)

# The keys must be "train".
estimator.fit(inputs={"train": trainingInput})

Validando a qualidade de dados aumentada

Antes de prosseguir com o ajuste fino, é crucial validar a qualidade dos dados aumentados:

1. Revise o sample_training_data.jsonl arquivo em seu bucket de saída. Esse arquivo contém 50 amostras aleatórias do conjunto de dados aumentado.

2. Inspecione manualmente essas amostras em busca de relevância, coerência e alinhamento com seu caso de uso.

3. Se a qualidade não atender às suas expectativas, talvez seja necessário ajustar os dados de entrada ou os parâmetros de destilação e executar novamente o processo de aumento de dados.

Após a conclusão do aumento dos dados, a segunda fase envolve o ajuste fino do modelo do aluno usando a Amazon. SageMaker HyperPod Para obter mais informações, consulte Ajuste fino supervisionado (SFT) de nível completo.

Na receita de treinamento do SFT, você pode passar o caminho do conjunto de dados retornado do trabalho anterior.

data_s3_path: "s3://[escrow-bucket]/[job-name]/distillation_data/training_data.jsonl"

Também substitua a configuração de treinamento recomendada gerada na etapa anterior.

Limitações

• Só suporta a técnica de ajuste fino SFT Nova nesses dados aumentados.

• Só suporta a técnica de ajuste fino SFT Nova na Amazon. SageMaker HyperPod

• Não há suporte para destilação multimodal.

• Não há suporte para modelos personalizados de professores.