Tutoriel : Commencez à utiliser le AWS SDK pour Python (Boto3)

Boto est le kit SDK Amazon Web Services (AWS) pour Python. Vous pouvez l'utiliser pour créer, configurer et gérer Services AWS. Pour obtenir des instructions sur l'installation de Boto3, consultez le kit SDK AWS pour Python (Boto3).

Après l'installation AWS SDK pour Python (Boto3), exécutez l'exemple de commande Python suivant pour vérifier que votre environnement est correctement configuré. Si votre environnement est correctement configuré, la réponse contient une liste de détecteurs. Si aucun détecteur n'a été créé, la liste est vide.

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

Au cours de cette étape, vous créez des ressources qui sont utilisées pour définir le modèle, l'événement et les règles.

Créer une variable

Une variable est un élément de données de votre jeu de données que vous souhaitez utiliser pour créer un type d'événement, un modèle et des règles.

Dans l'exemple suivant, l'CreateVariableAPI est utilisée pour créer deux variables. Les variables sont email_address etip_address. Attribuez-les aux types de variables correspondants : EMAIL_ADDRESS etIP_ADDRESS. Ces variables font partie de l'exemple de jeu de données que vous avez chargé. Lorsque vous spécifiez le type de variable, Amazon Fraud Detector interprète la variable lors de l'apprentissage du modèle et lors de l'obtention de prévisions. Seules les variables associées à un type de variable peuvent être utilisées pour l'apprentissage des modèles.

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>'
)   
           

Créer un type d'entité

Une entité représente la personne qui exécute l'événement et un type d'entité classe l'entité. Les catégories de clients, de marchands ou de comptes sont des exemples de classification.

Dans l'exemple suivant, PutEntityType l'API est utilisée pour créer un type d'sample_customerentité.

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

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

Créer une étiquette

Un label classe un événement comme frauduleux ou légitime et est utilisé pour entraîner le modèle de détection des fraudes. Le modèle apprend à classer les événements à l'aide de ces valeurs d'étiquette.

Dans l'exemple suivant, l'API Putlabel est utilisée pour créer deux étiquettes, fraud etlegit.

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'
)
 

Avec Amazon Fraud Detector, vous créez des modèles qui évaluent les risques et génèrent des prévisions de fraude pour des événements individuels. Un type d'événement définit la structure d'un événement individuel.

Dans l'exemple suivant, l'PutEventTypeAPI est utilisée pour créer un type d'événementsample_registration. Vous définissez le type d'événement en spécifiant les variables (email_address,ip_address), le type d'entité (sample_customer) et les libellés (fraud,legit) que vous avez créés à l'étape précédente.

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

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

Amazon Fraud Detector forme des modèles pour qu'ils apprennent à détecter les fraudes pour un type d'événement spécifique. À l'étape précédente, vous avez créé le type d'événement. Au cours de cette étape, vous allez créer et entraîner un modèle pour le type d'événement. Le modèle fait office de conteneur pour les versions de votre modèle. Chaque fois que vous entraînez un modèle, une nouvelle version est créée.

Utilisez les exemples de codes suivants pour créer et entraîner un modèle Online Fraud Insights. Ce modèle s'appellesample_fraud_detection_model. Il concerne le type d'événement sample_registration en utilisant l'exemple de jeu de données d'enregistrement de compte que vous avez chargé sur Amazon S3.

Pour plus d'informations sur les différents types de modèles pris en charge par Amazon Fraud Detector, consultezChoisissez un type de modèle.

Création d’un modèle

Dans l'exemple suivant, l'CreateModelAPI est utilisée pour créer un modèle.

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

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

Entraînez un mannequin

Dans l'exemple suivant, l'CreateModelVersionAPI est utilisée pour entraîner le modèle. Spécifiez l'trainingDataSourceemplacement Amazon S3 'EXTERNAL_EVENTS' pour lequel vous avez stocké votre exemple de jeu RoleArn de données et le compartiment Amazon S3 pour lequel vous avez stockéexternalEventsDetail. Dans le trainingDataSchema champ Paramètre, indiquez comment Amazon Fraud Detector interprète les données d'exemple. Spécifiez plus précisément les variables à inclure et la manière de classer les libellés des événements.

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://amzn-s3-demo-bucket/your-example-data-filename.csv',
              'dataAccessRoleArn' : 'role_arn'
}
)

Vous pouvez entraîner votre modèle plusieurs fois. Chaque fois que vous entraînez un modèle, une nouvelle version est créée. Une fois la formation du modèle terminée, l'état de la version du modèle est mis à jour àTRAINING_COMPLETE. Vous pouvez consulter le score de performance du modèle et d'autres mesures de performance du modèle.

Examiner les performances du modèle

Une étape importante de l'utilisation d'Amazon Fraud Detector consiste à évaluer la précision de votre modèle à l'aide des scores des modèles et des mesures de performance. Une fois la formation du modèle terminée, Amazon Fraud Detector valide les performances du modèle en utilisant les 15 % de vos données qui n'ont pas été utilisées pour entraîner le modèle. Il génère un score de performance du modèle et d'autres mesures de performance.

Utilisez l'DescribeModelVersionsAPI pour examiner les performances du modèle. Consultez le score global de performance du modèle et toutes les autres mesures générées par Amazon Fraud Detector pour ce modèle.

Pour en savoir plus sur le score de performance du modèle et les mesures de performance, consultez Scores des modèles etMétriques de performance des modèles.

Vous pouvez vous attendre à ce que tous les modèles Amazon Fraud Detector que vous avez formés disposent de mesures de performance de détection des fraudes réelles, similaires à celles de ce didacticiel.

Déployer un modèle

Après avoir examiné les indicateurs de performance de votre modèle entraîné, déployez-le et mettez-le à la disposition d'Amazon Fraud Detector pour générer des prévisions de fraude. Pour déployer le modèle entraîné, utilisez l'UpdateModelVersionStatusAPI. Dans l'exemple suivant, il est utilisé pour mettre à jour l'état de la version du modèle sur ACTIVE.

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'
)
 

Un détecteur contient la logique de détection, telle que les modèles et les règles. Cette logique s'applique à un événement particulier que vous souhaitez évaluer pour détecter toute fraude. Une règle est une condition que vous spécifiez pour indiquer à Amazon Fraud Detector comment interpréter les valeurs des variables lors de la prédiction. Et le résultat est le résultat d'une prédiction de fraude. Un détecteur peut avoir plusieurs versions, chaque version ayant le statut DRAFT , ACTIVE ou INACTIVE. Une version de détecteur doit être associée à au moins une règle.

Utilisez les exemples de codes suivants pour créer un détecteur, des règles, un résultat et pour publier le détecteur.

Création d'un détecteur

Dans l'exemple suivant, l'PutDetectorAPI est utilisée pour créer un sample_detector détecteur pour le type sample_registration d'événement.

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

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

Créez des résultats

Des résultats sont créés pour chaque résultat de prédiction de fraude possible. Dans l'exemple suivant, l'PutOutcomeAPI est utilisée pour créer trois résultats : verify_customerreview, etapprove. Ces résultats sont ensuite attribués à des règles.

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'
)
            
        

Créez des règles

La règle comprend une ou plusieurs variables de votre ensemble de données, une expression logique et un ou plusieurs résultats.

Dans l'exemple suivant, l'CreateRuleAPI est utilisée pour créer trois règles différentes : high_riskmedium_risk, etlow_risk. Créez des expressions de règles pour comparer la sample_fraud_detection_model_insightscore valeur du score de performance du modèle à différents seuils. Il s'agit de déterminer le niveau de risque associé à un événement et d'attribuer le résultat défini à l'étape précédente.

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']
     )
            
        

Création d'une version du détecteur

Une version de détection définit le modèle et les règles qui sont utilisés pour obtenir des prévisions de fraude.

Dans l'exemple suivant, l'CreateDetectorVersionAPI est utilisée pour créer une version du détecteur. Pour ce faire, il fournit des détails sur la version du modèle, des règles et un mode d'exécution des règles FIRST_MATCHED. Un mode d'exécution de règles spécifie la séquence d'évaluation des règles. Le mode d'exécution des règles FIRST_MATCHED spécifie que les règles sont évaluées de manière séquentielle, de la première à la dernière, en s'arrêtant à la première règle correspondante.

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'
)
            
        

La dernière étape de ce didacticiel utilise le détecteur sample_detector créé à l'étape précédente pour générer des prévisions de fraude pour le type d'sample_registrationévénement en temps réel. Le détecteur évalue les exemples de données qui sont chargés sur Amazon S3. La réponse inclut les scores de performance du modèle ainsi que tous les résultats associés aux règles correspondantes.

Dans l'exemple suivant, l'GetEventPredictionAPI est utilisée pour fournir les données d'un seul enregistrement de compte à chaque demande. Pour ce didacticiel, prenez les données (adresse e-mail et adresse IP) du fichier de données d'exemple d'enregistrement de compte. Chaque ligne (ligne) située après la ligne d'en-tête supérieure représente les données d'un seul événement d'enregistrement de compte.

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'
}
)         
        

Après avoir terminé ce didacticiel, vous avez effectué les opérations suivantes :