As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Validação de modelos em produção
O SageMaker AI permite testar vários modelos ou versões de modelo por trás do mesmo endpoint usando variantes de produção. Uma variante consiste em uma instância de ML e nos componentes de serviço especificados em um modelo do SageMaker AI. Você pode ter várias variantes por trás de um endpoint. Cada variante pode ter um tipo de instância diferente ou um modelo do SageMaker AI que pode ser escalado de forma automática independentemente dos outros. Os modelos dentro das variantes podem ser treinados usando conjuntos de dados diferentes, algoritmos diferentes, estruturas de ML diferentes ou qualquer combinação destes. Todas as variantes por trás de um endpoint compartilham o mesmo código de inferência. O SageMaker AI oferece permite dois tipos de variante: de produção e de sombra.
Se você tiver várias variantes de produção por trás de um endpoint, poderá alocar uma parte de suas solicitações de inferência para cada variante. Cada solicitação é encaminhada para somente uma das variantes de produção. A variante de produção para a qual a solicitação foi roteada fornece a resposta ao chamador. Você pode comparar o desempenho das variantes de produção em relação umas às outras.
Você também pode ter uma variante de sombra correspondente a uma variante de produção por trás de um endpoint. Uma parte das solicitações de inferência que vão para a variante de produção é replicada para a variante sombra. As respostas da variante sombra são registradas para comparação e não são devolvidas ao chamador. Isso permite testar o desempenho da variante de sombra sem expor o chamador à resposta produzida pela variante de sombra.
**Topics**
+ [Teste de modelos com variantes de produção](model-ab-testing.md)
+ [Teste de modelos com variantes de sombra](model-shadow-deployment.md)
# Teste de modelos com variantes de produção
Nos fluxos de trabalho de ML de produção, engenheiros e cientistas de dados frequentemente tentam melhorar o desempenho de várias maneiras, como realizando [Ajuste automático do modelo com SageMaker IA](automatic-model-tuning.md), treinando em dados adicionais ou mais recentes e melhorando a seleção de atributos usando instâncias atualizadas e contêineres de serviço. Você pode usar variantes de produção para comparar seus modelos, instâncias e contêineres e escolher o candidato com melhor desempenho para responder às solicitações de inferência.
Com os endpoints multivariantes de SageMaker IA, você pode distribuir solicitações de invocação de endpoints em várias variantes de produção, fornecendo a distribuição do tráfego para cada variante, ou você pode invocar uma variante específica diretamente para cada solicitação. Neste tópico, analisamos ambos os métodos para testar modelos de ML.
**Topics**
+ [Testar modelos especificando a distribuição de tráfego](#model-testing-traffic-distribution)
+ [Testar modelos invocando variantes específicas](#model-testing-target-variant)
+ [Exemplo de A/B teste de modelo](#model-ab-test-example)
## Testar modelos especificando a distribuição de tráfego
Para testar vários modelos distribuindo o tráfego entre eles, especifique a porcentagem do tráfego que é roteada para cada modelo especificando o peso de cada variante de produção na configuração do endpoint. Para mais informações, consulte [CreateEndpointConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpointConfig.html). O diagrama a seguir mostra como isso funciona mais detalhadamente.
![\[Exemplo mostrando como a distribuição de tráfego entre modelos usando InvokeEndpoint funciona na SageMaker IA.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/model-traffic-distribution.png)
## Testar modelos invocando variantes específicas
Para testar vários modelos invocando modelos específicos para cada solicitação, especifique a versão específica do modelo que você deseja invocar fornecendo um valor para o `TargetVariant` parâmetro ao chamar. [InvokeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_runtime_InvokeEndpoint.html) SageMaker A IA garante que a solicitação seja processada pela variante de produção que você especificar. Se você já forneceu distribuição de tráfego e especificou um valor para o parâmetro `TargetVariant`, o roteamento direcionado substituirá a distribuição de tráfego aleatória. O diagrama a seguir mostra como isso funciona mais detalhadamente.
![\[Exemplo mostrando como a invocação de modelos específicos para cada solicitação usando InvokeEndpoint funciona na SageMaker IA.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/model-target-variant.png)
## Exemplo de A/B teste de modelo
Realizar A/B testes entre um modelo novo e um modelo antigo com tráfego de produção pode ser uma etapa final eficaz no processo de validação de um novo modelo. Nos A/B testes, você testa diferentes variantes de seus modelos e compara o desempenho de cada variante. Se a versão mais recente do modelo oferecer umo desempenho melhor do que a versão existente anterior, substitua a versão antiga do modelo pela nova versão em produção.
O exemplo a seguir mostra como realizar testes de A/B modelo. Para obter uma amostra de caderno que implementa esse exemplo, consulte [A/B Testing ML models in production](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker_endpoints/a_b_testing/a_b_testing.html).
### Etapa 1: Criar e implantar modelos
Primeiro, definimos onde nossos modelos estão localizados no Amazon S3. Esses locais são usados quando implantamos nossos modelos em etapas subsequentes:
```
model_url = f"s3://{path_to_model_1}"
model_url2 = f"s3://{path_to_model_2}"
```
Depois, criamos os objetos do modelo com a imagem e os dados do modelo. Esses objetos do modelo são usados para implantar variantes de produção em um endpoint. Os modelos são desenvolvidos treinando modelos de ML em conjuntos de dados diferentes, em algoritmos ou estruturas de trabalho de ML diferentes e em hiperparâmetros diferentes:
```
from sagemaker.amazon.amazon_estimator import get_image_uri
model_name = f"DEMO-xgb-churn-pred-{datetime.now():%Y-%m-%d-%H-%M-%S}"
model_name2 = f"DEMO-xgb-churn-pred2-{datetime.now():%Y-%m-%d-%H-%M-%S}"
image_uri = get_image_uri(boto3.Session().region_name, 'xgboost', '0.90-1')
image_uri2 = get_image_uri(boto3.Session().region_name, 'xgboost', '0.90-2')
sm_session.create_model(
name=model_name,
role=role,
container_defs={
'Image': image_uri,
'ModelDataUrl': model_url
}
)
sm_session.create_model(
name=model_name2,
role=role,
container_defs={
'Image': image_uri2,
'ModelDataUrl': model_url2
}
)
```
Agora criamos duas variantes de produção, cada uma com seus próprios requisitos de modelo e recurso diferentes (contagens e tipo de instância). Isso permite que você também teste modelos em tipos de instância diferentes.
Definimos um initial\$1weight de 1 para ambas as variantes. Isso significa que 50% das solicitações vão para a `Variant1` e os 50% restantes das solicitações vão para a `Variant2`. A soma dos pesos em ambas as variantes é 2 e cada variante tem atribuição de peso de 1. Isso significa que cada variante recebe 1/2, ou 50%, do tráfego total.
```
from sagemaker.session import production_variant
variant1 = production_variant(
model_name=model_name,
instance_type="ml.m5.xlarge",
initial_instance_count=1,
variant_name='Variant1',
initial_weight=1,
)
variant2 = production_variant(
model_name=model_name2,
instance_type="ml.m5.xlarge",
initial_instance_count=1,
variant_name='Variant2',
initial_weight=1,
)
```
Finalmente, estamos prontos para implantar essas variantes de produção em um endpoint de SageMaker IA.
```
endpoint_name = f"DEMO-xgb-churn-pred-{datetime.now():%Y-%m-%d-%H-%M-%S}"
print(f"EndpointName={endpoint_name}")
sm_session.endpoint_from_production_variants(
name=endpoint_name,
production_variants=[variant1, variant2]
)
```
### Etapa 2: Invocar os modelos implantados
Agora enviamos solicitações a esse endpoint para obter inferências em tempo real. Usamos distribuição de tráfego e direcionamento direto.
Primeiro, usamos a distribuição de tráfego configurada na etapa anterior. Cada resposta de inferência contém o nome da variante de produção que processa a solicitação, para que possamos ver que o tráfego para as duas variantes de produção é aproximadamente igual.
```
# get a subset of test data for a quick test
!tail -120 test_data/test-dataset-input-cols.csv > test_data/test_sample_tail_input_cols.csv
print(f"Sending test traffic to the endpoint {endpoint_name}. \nPlease wait...")
with open('test_data/test_sample_tail_input_cols.csv', 'r') as f:
for row in f:
print(".", end="", flush=True)
payload = row.rstrip('\n')
sm_runtime.invoke_endpoint(
EndpointName=endpoint_name,
ContentType="text/csv",
Body=payload
)
time.sleep(0.5)
print("Done!")
```
SageMaker A IA emite métricas como `Latency` e `Invocations` para cada variante na Amazon CloudWatch. Para obter uma lista completa das métricas que a SageMaker IA emite, consulte[Métricas de SageMaker IA da Amazon na Amazon CloudWatch](monitoring-cloudwatch.md). Vamos consultar CloudWatch para obter o número de invocações por variante, para mostrar como as invocações são divididas entre as variantes por padrão:
![\[Exemplo de CloudWatch número de invocações por variante.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/model-variant-invocations.png)
Agora vamos invocar uma versão específica do modelo especificando `Variant1` como a `TargetVariant` na chamada para `invoke_endpoint`.
```
print(f"Sending test traffic to the endpoint {endpoint_name}. \nPlease wait...")
with open('test_data/test_sample_tail_input_cols.csv', 'r') as f:
for row in f:
print(".", end="", flush=True)
payload = row.rstrip('\n')
sm_runtime.invoke_endpoint(
EndpointName=endpoint_name,
ContentType="text/csv",
Body=payload,
TargetVariant="Variant1"
)
time.sleep(0.5)
```
Para confirmar que todas as novas invocações foram processadas por`Variant1`, podemos consultar CloudWatch para obter o número de invocações por variante. Vemos que, para as invocações mais recentes (timestamp mais recente), todas as solicitações foram processadas pela `Variant1`, como tínhamos especificado. Não foram feitas invocações para a `Variant2`.
![\[Exemplo de CloudWatch número de invocações para cada variante.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/model-invocations-target1.png)
### Etapa 3: Avalie o desempenho do modelo
Para ver qual versão do modelo tem melhor desempenho, vamos avaliar a exatidão, a precisão, o recall, a pontuação F1 e o receptor operando charactersistic/Area sob a curva para cada variante. Primeiro, vamos ver essas métricas para a `Variant1`:
![\[Exemplo de gráfico de curva característica de operação do receptor para Variant1.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/model-curve.png)
Agora vamos ver as métricas para a `Variant2`:
![\[Exemplo de gráfico de curva característica de operação do receptor para Variant2.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/model2-curve.png)
Para a maioria de nossas métricas definidas, o desempenho da `Variant2` é melhor, então essa é a que queremos usar na produção.
### Etapa 4: Aumentar o tráfego para o melhor modelo
Agora que determinamos que a `Variant2` tem um desempenho melhor do que a `Variant1`, deslocamos mais tráfego para ela. Podemos continuar usando para `TargetVariant` invocar uma variante de modelo específica, mas uma abordagem mais simples é atualizar os pesos atribuídos a cada variante chamando. [UpdateEndpointWeightsAndCapacities](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpointWeightsAndCapacities.html) Isso altera a distribuição de tráfego para as variantes de produção sem exigir atualizações ao endpoint. Lembre-se da seção de configuração que definimos pesos variantes para dividir o tráfego 50/50. As CloudWatch métricas do total de invocações para cada variante abaixo nos mostram os padrões de invocação de cada variante:
![\[CloudWatch Métricas de exemplo para o total de invocações para cada variante.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/model-invocations-even-dist.png)
Agora, transferimos 75% do tráfego para `Variant2` atribuindo novos pesos a cada variante usando. `UpdateEndpointWeightsAndCapacities` SageMaker A IA agora envia 75% das solicitações de inferência para `Variant2` e 25% das solicitações restantes para`Variant1`.
```
sm.update_endpoint_weights_and_capacities(
EndpointName=endpoint_name,
DesiredWeightsAndCapacities=[
{
"DesiredWeight": 25,
"VariantName": variant1["VariantName"]
},
{
"DesiredWeight": 75,
"VariantName": variant2["VariantName"]
}
]
)
```
As CloudWatch métricas do total de invocações para cada variante nos mostram mais invocações para do que para: `Variant2` `Variant1`
![\[CloudWatch Métricas de exemplo para o total de invocações para cada variante.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/model-invocations-75-25.png)
Podemos continuar monitorando nossas métricas e, quando estivermos satisfeitos com o desempenho de uma variante, podemos rotear 100% do tráfego para essa variante. Usamos [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpointWeightsAndCapacities.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpointWeightsAndCapacities.html) para atualizar as atribuições de tráfego para as variantes. O peso para `Variant1` é definido como 0 e o peso para `Variant2` é definido como 1. SageMaker A IA agora envia 100% de todas as solicitações de inferência para o. `Variant2`
```
sm.update_endpoint_weights_and_capacities(
EndpointName=endpoint_name,
DesiredWeightsAndCapacities=[
{
"DesiredWeight": 0,
"VariantName": variant1["VariantName"]
},
{
"DesiredWeight": 1,
"VariantName": variant2["VariantName"]
}
]
)
```
As CloudWatch métricas do total de invocações para cada variante mostram que todas as solicitações de inferência estão sendo processadas `Variant2` e não há solicitações de inferência processadas por. `Variant1`
![\[CloudWatch Métricas de exemplo para o total de invocações para cada variante.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/model-invocations-best-model.png)
Agora é possível atualizar o endpoint com segurança e excluir a `Variant1` do endpoint. Também é possível continuar testando novos modelos em produção adicionando novas variantes ao endpoint e seguindo as etapas de 2 a 4.
# Teste de modelos com variantes de sombra
Você pode usar as implantações de sombra de modelo do SageMaker AI para criar variantes de sombra de longa duração e validar qualquer novo componente possível da sua pilha de serviços de modelos antes de promovê-lo à produção. O diagrama a seguir mostra como as variantes de sombra funcionam mais detalhadamente.
![\[Detalhes de uma variante de sombra.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/juxtaposer/shadow-variant.png)
## Implemente variantes de sombra
O exemplo de código a seguir mostra como você pode implantar programaticamente variantes de sombra. Substitua o *texto do espaço reservado* na política de exemplo por suas próprias informações.
1. Crie dois modelos do SageMaker AI: um para sua variante de produção e outro para sua variante de sombra.
```
import boto3
from sagemaker import get_execution_role, Session
aws_region = "aws-region"
boto_session = boto3.Session(region_name=aws_region)
sagemaker_client = boto_session.client("sagemaker")
role = get_execution_role()
bucket = Session(boto_session).default_bucket()
model_name1 = "name-of-your-first-model"
model_name2 = "name-of-your-second-model"
sagemaker_client.create_model(
ModelName = model_name1,
ExecutionRoleArn = role,
Containers=[
{
"Image": "ecr-image-uri-for-first-model",
"ModelDataUrl": "s3-location-of-trained-first-model"
}
]
)
sagemaker_client.create_model(
ModelName = model_name2,
ExecutionRoleArn = role,
Containers=[
{
"Image": "ecr-image-uri-for-second-model",
"ModelDataUrl": "s3-location-of-trained-second-model"
}
]
)
```
1. Crie uma configuração de endpoint. Especifique suas variantes de produção e de sombra na configuração.
```
endpoint_config_name = name-of-your-endpoint-config
create_endpoint_config_response = sagemaker_client.create_endpoint_config(
EndpointConfigName=endpoint_config_name,
ProductionVariants=[
{
"VariantName": name-of-your-production-variant,
"ModelName": model_name1,
"InstanceType": "ml.m5.xlarge",
"InitialInstanceCount": 1,
"InitialVariantWeight": 1,
}
],
ShadowProductionVariants=[
{
"VariantName": name-of-your-shadow-variant,
"ModelName": model_name2,
"InstanceType": "ml.m5.xlarge",
"InitialInstanceCount": 1,
"InitialVariantWeight": 1,
}
]
)
```
1. Crie um endpoint do .
```
create_endpoint_response = sm.create_endpoint(
EndpointName=name-of-your-endpoint,
EndpointConfigName=endpoint_config_name,
)
```