O blog da AWS
Monitoramento de modelos de ML em produção em grande escala usando o Amazon SageMaker Model Monitor
Por Sireesha Muppala, Archana Padmasenan e David Nigenda
Os modelos de aprendizado de máquina (ML) estão impactando as decisões de negócios de organizações em todo o mundo, desde serviços de varejo e financeiros a veículos autônomos e exploração espacial. Para essas organizações, treinar e implantar modelos de ML em produção é apenas um passo para alcançar as metas de negócios. O desempenho do modelo pode degradar ao longo do tempo por várias razões, como a mudança dos padrões de compra do consumidor no setor de varejo e a mudança das condições econômicas no setor financeiro. A degradação da qualidade do modelo tem um impacto negativo nos resultados dos negócios. Para resolver proativamente esse problema, monitorar o desempenho de um modelo em produção é um processo crítico. O monitoramento contínuo dos modelos de produção permite identificar o tempo e a frequência certas para treinar novamente e atualizar o modelo.
O Amazon SageMaker é um serviço totalmente gerenciado que permite que desenvolvedores e cientistas de dados criem, treinem e implementem modelos de ML com rapidez e facilidade em qualquer escala. Depois de treinar um modelo de ML, você pode implantá-lo em endpoints SageMaker totalmente gerenciados e que podem servir inferências em tempo real com baixa latência. Depois de implantar seu modelo, você pode usar o Amazon SageMaker Model Monitor para monitorar continuamente a qualidade do seu modelo de ML em tempo real. Você também pode configurar alertas para notificar e acionar ações se qualquer desvio no desempenho do modelo for observado. A detecção precoce e proativa desses desvios permite que você tome ações corretivas, como coletar novos dados de treinamento de verdade, modelos de reciclagem e auditoria de sistemas upstream, sem ter que monitorar manualmente modelos ou criar ferramentas adicionais.
Neste post, discutimos o monitoramento da qualidade de um modelo de classificação por meio de métricas de classificação como precisão.
Visão geral da solução
O diagrama a seguir ilustra o fluxo de trabalho de alto nível do Model Monitor. Você começa com um endpoint para monitorar e configurar uma fração de dados de inferência a serem capturados em tempo real e armazenados em um bucket do Amazon Simple Storage Service (Amazon S3) de sua escolha. Model Monitor permite capturar ambos os dados de entrada enviados para um endpoint e previsões feitas pelo modelo. Depois disso, você pode criar um job de linha de base para gerar regras estatísticas e restrições que servem como base para sua análise de modelo posteriormente. Em seguida, você define o trabalho de monitoramento e anexá-lo a um endpoint por meio de uma programação.
O Model Monitor inicia o monitoramento de tarefas para analisar os dados de previsão do modelo coletados durante um determinado período. Para monitorar características de desempenho do modelo, como precisão em tempo real, o Model Monitor permite que você ingerir os rótulos de Ground Truth coletados de seus aplicativos. O Model Monitor mescla automaticamente as informações de verdade base com dados de previsão para calcular as métricas de desempenho do modelo.
O Model Monitor oferece quatro tipos diferentes de recursos de monitoramento para detectar e mitigar a deriva do modelo em tempo real:
- Qualidade dos dados — Ajuda a detectar alterações nas propriedades estatísticas de variáveis independentes e alerta-o quando uma deriva é detectada.
- Qualidade do modelo — Monitora as características de desempenho do modelo, como precisão e precisão em tempo real e alerta quando há uma degradação no desempenho do modelo.
- Viés de modelo — Ajuda você a identificar viés indesejados em seus modelos de ML e notificá-lo quando um viés é detectado.
- Explicabilidade do modelo — Alerta quando há uma alteração na importância relativa das atribuições de recursos.
Para obter mais informações, consulte Monitor de modelo do Amazon SageMaker.
O resto deste post mergulha em um notebook com as várias etapas envolvidas no monitoramento de um modelo de classificação binária pré-treinado e implantado do cliente XGBoost. Você pode usar uma abordagem semelhante para monitorar um modelo de regressão para aumentar as taxas de erro.
Para ver notebooks detalhados sobre outros recursos do Model Monitor, consulte os exemplos de drift de dados e notebooks de polarização no GitHub.
Além das etapas discutidas nesta publicação, existem outras etapas necessárias para importar bibliotecas e configurar permissões do AWS Identity and Access Management (IAM) e funções de utilitário definidas no notebook, que esta publicação não menciona. Você pode percorrer e executar o código com o seguinte notebook no repositório do GitHub.
Monitoramento da qualidade do
Para monitorar a qualidade do nosso modelo, concluímos duas etapas de alto nível:
- Implante um modelo pré-treinado com captura de dados ativada
- Gerar um baseline para o desempenho da qualidade do modelo
Implantação de um modelo pré-treinado
Nesta etapa, você implanta um modelo de previsão de rotatividade XGBoost pré-treinado em um endpoint SageMaker. O modelo foi treinado usando o XGB Churn Prediction Notebook. Se você tem um modelo pré-treinado que deseja monitorar, você pode usar seu próprio modelo nesta etapa.
- Faça upload de um artefato de modelo treinado em um bucket do S3:
s3_key = f"s3://{bucket}/{prefix}" model_url = S3Uploader.upload("model/xgb-churn-prediction-model.tar.gz", s3_key) model_url
Você deve ver uma saída semelhante ao seguinte código:
s3: //sagemaker-us-west-2-xxxxxxxxxxxx/sagemaker/DEMO-ModelMonitor-20200901/xgb-churn-prediction-model.tar.gz
2. Crie um objeto de modelo do SageMaker:
3. Crie uma variável para especificar os parâmetros de captura de dados. Para habilitar a captura de dados para monitorar a qualidade dos dados do modelo, especifique a opção de captura chamada DataCaptureConfig. Você pode capturar o payload do pedido, o payload da resposta, ou ambos com esta configuração.
endpoint_name = f"DEMO-xgb-churn-model-quality-monitor-{datetime.utcnow():%Y-%m-%d-%H%M}" print("EndpointName =", endpoint_name) data_capture_config = DataCaptureConfig( enable_capture=True, sampling_percentage=100, destination_s3_uri=s3_capture_upload_path) model.deploy(initial_instance_count=1, instance_type='ml.m4.xlarge', endpoint_name=endpoint_name, data_capture_config=data_capture_config)
4. Crie o objeto SageMaker Predictor a partir do endpoint a ser usado para invocar o modelo:
rom sagemaker.predictor import Predictor predictor = Predictor(endpoint_name=endpoint_name, sagemaker_session=session, serializer=CSVSerializer())
Geração de uma linha de base para o desempenho da qualidade do modelo
Nesta etapa, você gera uma qualidade de modelo de baseline que pode ser usada para monitorar continuamente a qualidade do modelo. Para gerar o baseline de qualidade do modelo, primeiro você invoca o endpoint criado anteriormente usando dados de validação. As previsões do modelo implantado usando esses dados de validação são usadas como um conjunto de dados de linha de base. Você pode usar o conjunto de dados de treinamento ou validação para criar a linha de base. Em seguida, use o Model Monitor para executar um job de linha de base que calcula dados de desempenho do modelo e sugere restrições de qualidade do modelo com base no conjunto de dados da linha de base.
- Invocar o endpoint com o seguinte código:
limit = 200 #Need at least 200 samples to compute standard deviations i = 0 with open(f"test_data/{validate_dataset}", "w") as baseline_file: baseline_file.write("probability,prediction,label\n") # our header with open('test_data/validation.csv', 'r') as f: for row in f: (label, input_cols) = row.split(",", 1) probability = float(predictor.predict(input_cols)) prediction = "1" if probability > churn_cutoff else "0" baseline_file.write(f"{probability},{prediction},{label}\n") i += 1 if i > limit: break print(".", end="", flush=True) sleep(0.5)
2. Examine as previsões do modelo:
!head test_data/validation_with_predictions.csv
Você vê uma saída semelhante ao seguinte código:
probabilidade, previsão, rótulo 0.01516005303710699,0,0 0.1684480607509613,0,0 0.21427156031131744,0,0 0.06330718100070953,0,0 0.02791607193648815,0,0 0.014169521629810333,0,0 0.00571369007229805,0,0 0.10534518957138062,0,0 0.025899196043610573,0,0
Em seguida, você configura um job de processamento para gerar regras e restrições estatísticas (referidas como seu baseline) contra as quais o desvio de qualidade do modelo pode ser detectado. O Model Monitor sugere um conjunto de estatísticas e restrições padrão da linha de base. Você também pode trazer restrições de linha de base personalizadas.
3. Comece fazendo o upload dos dados e previsões de validação para o Amazon S3:
baseline_dataset_uri = S3Uploader.upload(f"test_data/{validate_dataset}", baseline_data_uri) baseline_dataset_uri
4. Crie o monitor de qualidade do modelo:
churn_model_quality_monitor = ModelQualityMonitor( role=role, instance_count=1, instance_type='ml.m5.xlarge', volume_size_in_gb=20, max_runtime_in_seconds=1800, sagemaker_session=session
5. Execute o job de processamento de sugestão de linha de base:
job = churn_model_quality_monitor.suggest_baseline ( job_name=baseline_job_name, baseline_dataset=baseline_dataset_uri, dataset_format=DatasetFormat.csv (header=true), output_s3_uri = baseline_results_uri, problem_type='BinaryClassification', inference_attribute= “predição”, probability_attribute= “probabilidade”, ground_truth_attribute= “rótulo”
-
)
job.wait (logs=false)
Quando o job de baseline estiver concluído, você pode explorar as métricas e restrições geradas.
6. Exiba as métricas de classificação binária com o seguinte código:
binary_metrics = baseline_job.baseline_statistics () .body_dict ["binary_classification_metrics"] pd.json_normalize (linha de base ["binary_classification_metrics"]) .T
A captura de tela a seguir mostra seus resultados.
7. Exibir as restrições geradas:
constraints = json.loads(S3Downloader.read_file(constraints_file)) constraints["binary_classification_constraints"] {'recall': {'threshold': 0.5714285714285714, 'comparison_operator': 'LessThanThreshold'}, 'precision': {'threshold': 1.0, 'comparison_operator': 'LessThanThreshold'}, 'accuracy': {'threshold': 0.9402985074626866,'comparison_operator': 'LessThanThreshold'), 'true_positive_rate': {'threshold': 0.5714285714285714,'comparison_operator': 'LessThanThreshold'}, 'true_negative_rate': {'threshold': 1.0, 'comparison_operator': 'LessThanThreshold'}, 'false_positive_rate': {'threshold': 0.0,'comparison_operator': 'GreaterThanThreshold'), 'false_negative_rate': {'threshold': 0.4285714285714286,'comparison_operator': 'GreaterThanThreshold'}, 'auc': {'threshold': 1.0, 'comparison_operator': 'LessThanThreshold'}, 'f0_5': {'threshold': 0.8695652173913042,'comparison_operator': 'LessThanThreshold'}, 'f1': {'threshold': 0.7272727272727273,'comparison_operator': 'LessThanThreshold'}, 'f2': {'threshold': 0.625, 'comparison_operator': 'LessThanThreshold'}}
A partir das restrições geradas, você pode ver que o monitoramento do modelo garante que a pontuação de recall do seu modelo não regresse e caia abaixo de 0,571. Da mesma forma, ele garante que você está alertado quando a precisão cai abaixo de 1.0. Isso pode ser muito agressivo, mas você pode modificar as restrições geradas com base no seu caso de uso e nas necessidades de negócios.
Configurando o monitoramento contínuo do modelo
Agora que você tem o baseline da qualidade do modelo, você configura um trabalho contínuo de monitoramento de modelo que monitora a qualidade do modelo implantado em relação ao baseline para identificar a deriva da qualidade do modelo.
Além do baseline gerado, o Model Monitor precisa de duas entradas adicionais: previsões feitas pelo endpoint do modelo implantado e os dados de verdade base a serem fornecidos pelo aplicativo que consome modelos. Como você já habilitou a captura de dados no endpoint, os dados de previsão são capturados no Amazon S3. Os dados de ground truth dependem do que seu modelo está prevendo e do que é o caso de uso comercial. Nesse caso, como o modelo está prevendo a rotatividade do cliente, os dados de verdade fundamental podem indicar se o cliente realmente deixou a empresa ou não. Para os propósitos deste caderno, você gera dados sintéticos como verdade fundamental.
- Primeiro gere tráfego para o valor-limite definido. Se não houver tráfego, os trabalhos de monitoramento serão marcados como Falha porque não há dados a serem processados. Consulte o seguinte código:
def invoke_endpoint (ep_name, file_name):
with open (file_name, 'r') as f:
i = 0
for line in f:
payload = linha.rstrip ('\ n')
response = session.sagemaker_runtime_client.invoke_endpoint (
endpointName=Endpoint_name,
contentType='Text/CSV',
body=payload,
inferenceId=str (i), # ID exclusivo por linha
) ["Corpo"] .read ()
i += 1
sleep (1)
def invoke_endpoint_forever ():
while True:
invoke_endpoint (endpoint_name, 'test_data/test-dataset-input-cols.csv')
thread = Thread (alvo = invoke_endpoint_forever)
thread.start ()
2. Visualize os dados capturados com o seguinte código:
for _ in range (120):
capture_files = labled(s3Downloader.list (f "{s3_capture_upload_path}/{endpoint_name}”))
if capture_files:
capture_file = S3Downloader.read_file (capture_files [-1]) .split (“\ n”)
capture_record = json.loads (capture_file [0])
if “InferenceId” in capture_record ["eventMetadata"]:
break
print (”.“, end="”, flush=true)
sleep (1)
-
print ()
-
print (“Arquivos de captura encontrados:”)
print (“\ n “.join (capture_files [-5:]) Você vê uma saída semelhante ao seguinte: Arquivos de captura encontrados: s3: //sagemaker-US-West-2-303008809627/Sagemaker/churn-modelo-qualitymonitor-20201129/datacapture/demo-xgb-churn-modelo-qualidade-monitor-2020-12-01-2214/Alltraffic/2020/12/01/22/23-36-108-9df12912-2696-431e-a4ef-A76b3c3f7D32.jsonl s3: //sagemaker-US-West-2-303008809627/Sagemaker/churn-modelQuality Monitor-20201129/DataCapture/demo-XGB-churn-modelo-qualidade-monitor-2020-12-01-2214/Alltraffic/2020/12/01/22/24-36-254-DF884bcb-405C-4277-9CC8-517F3F31b56f.Jsonl
3. Exibir o conteúdo de um único arquivo:
print (json.dumps (capture_record, indent=2))
Você vê uma saída semelhante ao seguinte:
{
“CaptureData”: {
“EndPointInput”: {
“observedContentType”: “text/csv”,
“mode”: “INPUT”,
“data”: “75,0,109.0,88,259.3,120,182.1,119,13.3,3,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,1,0
“encoding”: “CSV”
},
“EndPointOutput”: {
“observedContentType”: “text/csv; charset=utf-8",
“mode”: “SAÍDA”,
“data”: “0.7990730404853821",
“encoding”: “CSV”
}
},
“EventMetadata”: {
“EventID”: “01e27fce-a00a-4707-847e-9748d6a8e580",
“InferenceTime”: “2020-12-01T 22:24:36 Z”
},
“EventVersion”: “0"
}
O Model Monitor permite que você ingerir os dados de verdade de base coletados periodicamente de seu aplicativo e mesclá-los com dados de previsão para calcular métricas de desempenho do modelo. Você pode carregar periodicamente os rótulos de verdade à medida que eles chegam e fazem upload para o Amazon S3. O Model Monitor mescla automaticamente a verdade fundamental com os dados de previsão e avalia o desempenho do modelo em relação à verdade do solo. Os dados mesclados são armazenados no Amazon S3 e podem ser acessados posteriormente para reciclagem de seus modelos. Você pode criptografar os dados neste bucket e configurar segurança refinada, mecanismos de controle de acesso e políticas de retenção de dados.
4. Insira o código a seguir para gerar a verdade de base da maneira que o contêiner de mesclagem de primeira parte do SageMaker espera:
Import random
def ground_truth_with_id (inference_id):
seed (inference_id) # para obter resultados consistentes
rand = aleatório ()
return {
'GroundTruthData': {
data: “1" if rand < 0.7 else “0", # geram aleatoriamente rótulos positivos 70% do tempo
' encoding ':' CSV '
},
'EventMetadata': {
'eventId': str (inference_id),
},
'eventVersion': '0',
}
def upload_ground_truth (records, upload_time):
fake_records = [json.dumps (r) for r in records]
data_to_upload = “\ n” .join (fake_records)
target_s3_uri = f "{ground_truth_upload_path}/{upload_time: %Y/%M/%D/%H/%M%s} .jsonl”
print (f"Uploading {len (fake_records)} records for”, target_s3_uri)
s3uploader.upload_string_as_file_body (data_to_upload, target_s3_uri)
O trabalho de qualidade do modelo falhará se a captura de dados ou os dados de verdade do solo estiverem ausentes.
Em seguida, você configura um cronograma de monitoramento que monitora o desempenho em tempo real do modelo em relação à linha de base.
5. Defina o nome do agendador de monitoramento:
churn_monitor_schedule_name =
f"Demo-xgb-churn-monitoring-schedule- {datetime.utcnow () :%Y-%M-%D-%H%M}”
Agora você cria o objeto EndPointInput . Para a programação de monitoramento, você precisa especificar como interpretar a saída de um endpoint. Como o endpoint neste notebook produz dados CSV, o código a seguir especifica que a primeira coluna da saída, 0, contém uma probabilidade (de rotatividade neste exemplo). Você especifica ainda 0.5 como o corte usado para determinar um rótulo positivo (isto é, prever que um cliente irá rotular).
6. Crie o objeto EndPointInput com o seguinte código:
EndPointInput = EndPointInput (endpoint_name=predictor.endpoint_name, probability_attribute="0", probability_threshold_attribute=0.8, destination='/opt/ml/processing/input_data')
7. Crie o cronograma de monitoramento. Você especifica com que frequência o trabalho de monitoramento é executado usando ScheduleExpression. No código a seguir, definimos o cronograma para uma vez por hora. Para MonitoringType, especifique modelQuality.
response = churn_model_quality_monitor.create_monitoring_schedule ( monitor_schedule_name=churn_monitor_schedule_name, endpoint_input=EndpointInput, output_s3_uri = baseline_results_uri, problem_type='BinaryClassification', ground_truth_input=ground_truth_upload_path, constraints=baseline_job.suggested_constraints (), schedule_cron_expression=CronExpressionGenerator.hourly (), enable_cloudwatch_metrics=True )
Cada vez que o trabalho de monitoramento de qualidade do modelo é executado, ele primeiro executa um trabalho de mesclagem e, em seguida, um trabalho de monitoramento. O trabalho de mesclagem combina dois conjuntos de dados diferentes: dados de inferência coletados pela captura de dados habilitados nos dados de inferência de verdade e ponto de extremidade fornecidos por você.
8. Examine uma única execução do job de monitoramento agendado:
executions = churn_model_quality_monitor.list_executions ()
-
latest_execution = executions [-1]
-
describe ()
-
status = executions['MonitoringExecutionStatus']
while status in ["Pending”, “InProgress"]:
print (“Aguardando a execução terminar”, end= "”)
wait (logs=falso)
latest_job = latest_execution.describe ()
print ()
print (f "{latest_job ['ProcessingJobName']} job status:”, latest_job ['ProcessingJobStatus'])
print (f "{latest_job ['ProcessingJobName']} mensagem de saída do trabalho, se houver:”, latest_job.get ('exitMessage'))
print (f "{latest_job ['ProcessingJobName']} motivo da falha de trabalho, se houver:”, latest_job.get ('FailureReason'))
sleep (30) # execuções de qualidade do modelo consistem em dois trabalhos de processamento, aguarde o segundo trabalho para começar
latest_execution = churn_model_quality_monitor.list_executions () [-1]
execução = churn_model_quality_monitor.describe_schedule () ["lastMonitoringExecutionSummary"]
status = execução ['MonitoringExecutionStatus']
print (“Status de execução é:”, status)
if status != 'Ready':
print (execution)
print (“====STOP====\ n Nenhuma execução concluída para inspecionar mais. Aguarde até que uma execução seja concluída ou investigue falhas relatadas anteriormente.“
9. Verifique as violações contra as restrições da linha de base:
-
options.display.max_colwidth = Nenhum
-
violations = latest_execution.constraint_violations () .body_dict ["violações"]
-
violations_df = pd.json_normalize (violations)
violations_df.head (10)
A captura de tela a seguir mostra as várias violações geradas.
Nesta lista, você pode ver que a taxa de falso positivo e a taxa falso-negativa são maiores do que as restrições geradas ou modificadas durante a etapa de linha de base. Da mesma forma, as métricas de precisão e precisão são menores do que o esperado, indicando degradação da qualidade do modelo.
Analisando a qualidade do modelo com as métricas do Amazon CloudWatch
Além das violações, o cronograma de monitoramento também emite métricas do Amazon CloudWatch . Nesta etapa, você visualiza as métricas geradas e configura um alarme do CloudWatch para acionar quando a qualidade do modelo deriva dos limites da linha de base. Você também pode usar alarmes do CloudWatch para acionar ações corretivas, como recriar seu modelo ou atualizar o conjunto de dados de treinamento.
- Para exibir a lista das métricas do CloudWatch geradas, insira o seguinte código:
cw_client = boto3.session () .client ('cloudwatch')
namespace='AWS/SAGEMaker/Endpoints/Model-métricas'
cw_dimenstions= [
{
'Name': 'Ponto de extremidade',
'Value': endpoint_name
},
{
'Name': 'MonitoringSchedule',
'Value': churn_monitor_schedule_name
}
]
paginator = cw_client.get_paginator ('list_metrics')
for response in paginator.paginate (dimensions=CW_dimenstions, namespace=Namespace):
model_quality_metrics = response ['Metrics']
for metric in model_quality_metrics:
print (metric ['metricName']) Você vê uma saída semelhante ao seguinte: f0_5_best_constant_classifier f2_best_constant_classifier f1_best_constant_classifier auc precision accuracy_best_constant_classifier true_positive_rate f1 precision false_positive_rate f0_5 true_negative_rate false_negative_rate recall_best_constant_classifier precision_best_constant_classifier recall f2
2. Crie um alarme para quando uma métrica específica não atende ao limite configurado. No código a seguir, criamos um alarme se o valor F2 do modelo cair abaixo do limite sugerido pelas restrições de linha de base:
ALARM_NAME='MODEL_QUALITY_F2_SCORE'
alarm_desc='Aciona um alarme do cloudwatch quando a pontuação f2 se afasta das restrições da linha de base'
mdoel_quality_f2_drift_threshold=0.625 # #Definindo este limite propositalmente lento para ver o alarme rapidamente.
metric_name='f2'
namespace='AWS/SAGEMaker/Endpoints/Model-métricas'
#endpoint_name =endpoint_name
#monitoring_schedule_name =mon_schedule_name
put_metric_alarm (
alarmName=alarm_name,
alarmdescription=alarm_desc,
actionSenabled=True,
#AlarmActions = [sns_notifications_topic],
metricName=Metric_name,
namespace=Namespace,
Statistic='Média',
Dimensions = [
{
'Name': 'Ponto de extremidade',
'Value': endpoint_name
},
{
'Name': 'MonitoringSchedule',
'Value': churn_monitor_schedule_name
}
],
Period=600,
EvaluationPeriods=1,
DataPointsToalarm=1,
Threshold=MDOEL_QUALITY_F2_DRIFT_THRESHOLD,
comparisOnOperator='LessthanOrequalToThreshold',
treatMissingData='Violation'
)
Em alguns minutos, você verá um alarme do CloudWatch criado. O alarme mostra primeiramente os dados insuficientes do estado e então muda para Alerta. Você pode visualizar seu status no console do CloudWatch.
Depois de gerar o alarme, você pode decidir sobre quais ações você quer tomar sobre esses alertas. Uma possível ação poderia ser a atualização dos dados de formação e a reciclagem do modelo.
Visualizando os relatórios no Amazon SageMaker Studio
Você pode coletar todas as métricas emitidas pelo Model Monitor e visualizá-las no Amazon SageMaker Studio, um ambiente de desenvolvimento visual e totalmente integrado (IDE) para ML, para que você possa analisar visualmente o desempenho do seu modelo sem escrever código ou usar ferramentas de terceiros. Você também pode executar análises ad-hoc nos relatórios gerados em uma instância de notebook SageMaker.
A figura a seguir mostra métricas de amostra e gráficos no Studio. Execute o notebook no ambiente Studio para visualizar todas as métricas e gráficos relacionados ao exemplo de rotatividade do cliente.
Conclusão
O SageMaker Model Monitoring é uma ferramenta muito poderosa que permite que as organizações que empregam modelos de ML criem um ciclo contínuo de monitoramento e atualização de modelos. Este post discute a capacidade de monitoramento com foco no monitoramento da qualidade de um modelo de ML implantado. O notebook incluído na publicação fornece instruções detalhadas sobre o monitoramento de um modelo de classificação binária XGBoost, juntamente com uma visualização das restrições de linha de base geradas e violações contra as restrições de linha de base, e configura respostas automatizadas para as violações usando Alertas do CloudWatch. Esse fluxo de trabalho de ponta a ponta permite criar treinamentos contínuos de modelos, monitoramento e pipelines de atualização de modelos. Experimente o Model Monitor e deixe seu feedback nos comentários.
Este artigo foi traduzido do Blog da AWS em Inglês.
Sobre os Autores
Sireesha Muppala é uma arquiteta de soluções especialista em AI/ML da AWS, fornecendo orientação aos clientes sobre como arquitetar e implementar soluções de machine learning em grande escala. Ela recebeu seu Ph.D. em Ciência da Computação pela Universidade do Colorado, Colorado Springs. Em seu tempo livre, Sireesha adora correr e caminhar trilhas no Colorado.
David Nigenda é engenheiro de desenvolvimento de software na equipe do Amazon SageMaker. Seu trabalho atual se concentra em fornecer insights úteis sobre fluxos de trabalho de aprendizado de máquina de produção. Em seu tempo livre ele tenta acompanhar seus filhos.
Archana Padmasenan é gerente sênior de produto do Amazon SageMaker. Ela gosta de construir produtos que encantam os clientes.
Revisor
Joao Martins é arquiteto de soluções na AWS e atua no segmento Enterprise auxiliando clientes de Retail e CPG em geral para empresas que estão iniciando sua jornada para a nuvem.