Tutorial: Conceitos básicos deAWS SDK for Python (Boto3)

O Boto é o SDK da Amazon Web Services (AWS) para Python. Você pode usá-lo para criar, configurar e gerenciarServiços da AWS. Para obter instruções sobre como instalar o Boto3, consulte AWS SDK for Python (Boto3).

Depois de instalarAWS SDK for Python (Boto3), execute o seguinte comando de exemplo do Python para confirmar se seu ambiente está configurado corretamente. Se seu ambiente estiver configurado corretamente, a resposta conterá uma lista de detectores. Se nenhum detector tiver sido criado, a lista estará vazia.

import boto3
fraudDetector = boto3.client('frauddetector')
            
response = fraudDetector.get_detectors()
print(response)

Nesta etapa, você cria recursos que são usados para definir modelos, eventos e regras.

Criar variável

Uma variável é um elemento de dados do seu conjunto de dados que você deseja usar para criar tipo de evento, modelo e regras.

No exemplo a seguir, a CreateVariableAPI é usada para criar duas variáveis. As variáveis sãoemail_addressip_address e. Atribua-os aos tipos de variáveis correspondentes:EMAIL_ADDRESSIP_ADDRESS e. Essas variáveis fazem parte do conjunto de dados de exemplo que você enviou. Quando você especifica o tipo de variável, o Amazon Fraud Detector interpreta a variável durante o treinamento do modelo e ao obter previsões. Somente variáveis com um tipo de variável associado podem ser usadas para o treinamento do modelo.

import boto3
fraudDetector = boto3.client('frauddetector')

 #Create variable email_address
fraudDetector.create_variable(
    name = 'email_address',
    variableType = 'EMAIL_ADDRESS',
    dataSource = 'EVENT',
    dataType = 'STRING',
    defaultValue = '<unknown>'
)

#Create variable ip_address
fraudDetector.create_variable(
    name = 'ip_address',
    variableType = 'IP_ADDRESS',
    dataSource = 'EVENT',
    dataType = 'STRING',
    defaultValue = '<unknown>'
)   
           

Criar tipo de entidade

Uma entidade representa quem está realizando o evento e um tipo de entidade classifica a entidade. Exemplos de classificações incluem cliente, comerciante ou conta.

No exemplo a seguir, a PutEntityTypeAPI é usada para criar um tipo desample_customer entidade.

import boto3
fraudDetector = boto3.client('frauddetector')

fraudDetector.put_entity_type(
   name = 'sample_customer',
   description = 'sample customer entity type'
)
            
      

Criar rótulo

Um rótulo classifica um evento como fraudulento ou legítimo e é usado para treinar o modelo de detecção de fraude. O modelo aprende a classificar eventos usando esses valores de rótulo.

No exemplo a seguir, a API Putlabel é usada para criar dois rótulos,fraudlegit e.

import boto3
fraudDetector = boto3.client('frauddetector')

fraudDetector.put_label(
    name = 'fraud',
    description = 'label for fraud events'
)

fraudDetector.put_label(
    name = 'legit',
    description = 'label for legitimate events'
)
 

Com o Amazon Fraud Detector, você cria modelos que avaliam riscos e geram previsões de fraude para eventos individuais. Um tipo de evento define a estrutura de um evento individual.

No exemplo a seguir, a PutEventTypeAPI é usada para criar um tipo de eventosample_registration. Você define o tipo de evento especificando as variáveis (email_address,ip_address), tipo de entidade (sample_customer) e rótulos (fraud,legit) que você criou na etapa anterior.

import boto3
fraudDetector = boto3.client('frauddetector')

fraudDetector.put_event_type (
     name = 'sample_registration',
     eventVariables = ['ip_address', 'email_address'],
     labels = ['legit', 'fraud'],
     entityTypes = ['sample_customer'])            
        

O Amazon Fraud Detector treina modelos para aprender a detectar fraudes para um tipo de evento específico. Na etapa anterior, você criou o tipo de evento. Nesta etapa, você cria e treina um modelo para o tipo de evento. O modelo funciona como um contêiner para suas versões de modelo. Cada vez que você treina um modelo, uma nova versão é criada.

Use os códigos de exemplo a seguir para criar e treinar um modelo Online Fraud Insights. Esse modelo é chamadosample_fraud_detection_model. É para o tipo de eventosample_registration usando o conjunto de dados de exemplo de registro de conta que você enviou para o Amazon S3.

Para obter mais informações sobre os diferentes tipos de modelos compatíveis com o Amazon Fraud Detector, consulteEscolha um tipo de modelo.

Crie um modelo

No exemplo a seguir, a CreateModelAPI é usada para criar um modelo.

import boto3
fraudDetector = boto3.client('frauddetector')

fraudDetector.create_model (
       modelId = 'sample_fraud_detection_model',
       eventTypeName = 'sample_registration',
       modelType = 'ONLINE_FRAUD_INSIGHTS')
        

Treine um modelo

No exemplo a seguir, a CreateModelVersionAPI é usada para treinar o modelo. Especifique'EXTERNAL_EVENTS' para otrainingDataSource e o local do Amazon S3 em que você armazenou seu conjunto de dados RoleArnde exemplo e para o bucket do Amazon S3externalEventsDetail. ComotrainingDataSchema parâmetro, especifique como o Amazon Fraud Detector interpreta os dados de exemplo. Mais especificamente, especifique quais variáveis incluir e como classificar os rótulos dos eventos.

import boto3
fraudDetector = boto3.client('frauddetector')

fraudDetector.create_model_version (
         modelId = 'sample_fraud_detection_model',
         modelType = 'ONLINE_FRAUD_INSIGHTS',
         trainingDataSource = 'EXTERNAL_EVENTS',
         trainingDataSchema = {
            'modelVariables' : ['ip_address', 'email_address'],
            'labelSchema' : {
               'labelMapper' : {
                   'FRAUD' : ['fraud'],
                   'LEGIT' : ['legit']
        }
    }
}, 
         externalEventsDetail = {
              'dataLocation' : 's3://your-S3-bucket-name/your-example-data-filename.csv',
              'dataAccessRoleArn' : 'role_arn'
}
)

Você pode treinar seu modelo várias vezes. Cada vez que você treina um modelo, uma nova versão é criada. Depois que o treinamento do modelo for concluído, o status da versão do modelo será atualizado paraTRAINING_COMPLETE. Você pode revisar a pontuação de desempenho do modelo e outras métricas de desempenho do modelo.

Analise o desempenho do modelo

Uma etapa importante no uso do Amazon Fraud Detector é avaliar a precisão do seu modelo usando pontuações e métricas de desempenho do modelo. Depois que o treinamento do modelo for concluído, o Amazon Fraud Detector valida o desempenho do modelo usando 15% dos seus dados que não foram usados para treinar o modelo. Ele gera uma pontuação de performance do modelo e outras métricas de performance.

Use a DescribeModelVersionsAPI para analisar o desempenho do modelo. Veja a pontuação geral de desempenho do modelo e todas as outras métricas geradas pelo Amazon Fraud Detector para esse modelo.

Para saber mais sobre a pontuação de desempenho do modelo e as métricas de desempenho, consultePontuações do modeloMétricas de desempenho do modelo e.

Você pode esperar que todos os seus modelos treinados do Amazon Fraud Detector tenham métricas de desempenho de detecção de fraudes no mundo real, que são semelhantes às métricas deste tutorial.

Implante um modelo

Depois de analisar as métricas de desempenho do seu modelo treinado, implante o modelo e disponibilize-o para o Amazon Fraud Detector para gerar previsões de fraude. Para implantar o modelo treinado, use a UpdateModelVersionStatusAPI. No exemplo a seguir, ele é usado para atualizar o status da versão do modelo para ATIVO.

import boto3
fraudDetector = boto3.client('frauddetector')

fraudDetector.update_model_version_status (
     modelId = 'sample_fraud_detection_model',
     modelType = 'ONLINE_FRAUD_INSIGHTS',
     modelVersionNumber = '1.00',
     status = 'ACTIVE'
)
 

Um detector contém a lógica de detecção, como os modelos e as regras. Essa lógica é para um evento específico que você deseja avaliar como fraude. Uma regra é uma condição que você especifica para informar ao Amazon Fraud Detector como interpretará valores de variáveis durante a previsão. E o resultado é o resultado de uma previsão de fraude. Um detector pode ter várias versões, com cada versão tendo um status de RASCUNHO, ATIVO ou INATIVO. Uma versão do detector precisa estar associada a pelo menos uma regra.

Use os códigos de exemplo a seguir para criar detector, regras, resultados e publicar o detector.

Criar um detector

No exemplo a seguir, a PutDetectorAPI é usada para criar umsample_detector detector para o tipo desample_registration evento.

import boto3
fraudDetector = boto3.client('frauddetector')

fraudDetector.put_detector (
     detectorId = 'sample_detector',
     eventTypeName = 'sample_registration'
)
  

Crie resultados

Os resultados são criados para cada possível resultado de previsão de fraude. No exemplo a seguir, a PutOutcomeAPI é usada para criar três resultados -verify_customerreview,approve e. Esses resultados são posteriormente atribuídos às regras.

import boto3
fraudDetector = boto3.client('frauddetector')

fraudDetector.put_outcome(
     name = 'verify_customer',
     description = 'this outcome initiates a verification workflow'
    )

fraudDetector.put_outcome(
     name = 'review',
     description = 'this outcome sidelines event for review'
    )

fraudDetector.put_outcome(
     name = 'approve',
     description = 'this outcome approves the event'
)
            
        

Crie regras

A regra consiste em uma ou mais variáveis do seu conjunto de dados, uma expressão lógica e um ou mais resultados.

No exemplo a seguir, a CreateRuleAPI é usada para criar três regras diferentes:high_riskmedium_risk,low_risk e. Crie expressões de regras para comparar osample_fraud_detection_model_insightscore valor da pontuação de desempenho do modelo com vários limites. Isso é para determinar o nível de risco de um evento e atribuir um resultado que foi definido na etapa anterior.

import boto3
fraudDetector = boto3.client('frauddetector')

fraudDetector.create_rule(
     ruleId = 'high_fraud_risk',
     detectorId = 'sample_detector',
     expression = '$sample_fraud_detection_model_insightscore > 900',
     language = 'DETECTORPL',
     outcomes = ['verify_customer']
     )

fraudDetector.create_rule(
     ruleId = 'medium_fraud_risk',
     detectorId = 'sample_detector',
     expression = '$sample_fraud_detection_model_insightscore <= 900 and $sample_fraud_detection_model_insightscore > 700',
     language = 'DETECTORPL',
     outcomes = ['review']
     )

fraudDetector.create_rule(
     ruleId = 'low_fraud_risk',
     detectorId = 'sample_detector',
     expression = '$sample_fraud_detection_model_insightscore <= 700',
     language = 'DETECTORPL',
     outcomes = ['approve']
     )
            
        

Criar uma versão do detector

Uma versão do detector define o modelo e as regras que são usados para obter a previsão de fraudes.

No exemplo a seguir, a CreateDetectorVersionAPI é usada para criar uma versão do detector. Ele faz isso fornecendo detalhes da versão do modelo, regras e um modo de execução de regras FIRST_MATCHED. Um modo de execução de regras especifica a sequência para avaliar as regras. O modo de execução da regra FIRST_MATCHED especifica que as regras sejam avaliadas sequencialmente, da primeiro à última, parando na primeira regra correspondente.

import boto3
fraudDetector = boto3.client('frauddetector')

fraudDetector.create_detector_version(
      detectorId = 'sample_detector',
      rules = [{
          'detectorId' : 'sample_detector',
          'ruleId' : 'high_fraud_risk',
          'ruleVersion' : '1'
},
{
          'detectorId' : 'sample_detector',
          'ruleId' : 'medium_fraud_risk',
          'ruleVersion' : '1'
},
{
          'detectorId' : 'sample_detector',
          'ruleId' : 'low_fraud_risk',
          'ruleVersion' : '1'
}
],
      modelVersions = [{
          'modelId' : 'sample_fraud_detection_model',
          'modelType': 'ONLINE_FRAUD_INSIGHTS',
          'modelVersionNumber' : '1.00'
}      ],
      ruleExecutionMode = 'FIRST_MATCHED'
)
            
        

A última etapa deste tutorial usa o detectorsample_detector criado na etapa anterior para gerar previsões de fraude para o tipo desample_registration evento em tempo real. O detector avalia os dados de exemplo que são enviados para o Amazon S3. A resposta inclui as pontuações de desempenho do modelo, bem como quaisquer resultados associados às regras correspondentes.

No exemplo a seguir, a GetEventPredictionAPI é usada para fornecer dados de um único registro de conta com cada solicitação. Para este tutorial, pegue dados (email_address e ip_address) do arquivo de dados de exemplo de registro da conta. Cada linha (linha) após a linha do cabeçalho superior representa dados de um único evento de registro de conta.

import boto3
fraudDetector = boto3.client('frauddetector')

fraudDetector.get_event_prediction(
      detectorId = 'sample_detector',
      eventId = '802454d3-f7d8-482d-97e8-c4b6db9a0428',
      eventTypeName = 'sample_registration',
      eventTimestamp = '2020-07-13T23:18:21Z',
      entities = [{'entityType':'sample_customer', 'entityId':'12345'}],
 eventVariables = {
      'email_address': 'johndoe@exampledomain.com',
      'ip_address': '1.2.3.4'
}
)         
        

Depois de concluir este tutorial, você fez o seguinte: