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 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. Affectez-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 pendant l'entraînement du modèle et lors de l'obtention de prédictions. Seules les variables associées à un type de variable peuvent être utilisées pour l'entraînement du modèle.

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 réalise l'événement et un type d'entité classe l'entité. Les exemples de classifications incluent le client, le commerçant ou le compte.

Dans l'exemple suivant, PutEntityTypel'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

Une étiquette classe un événement comme frauduleux ou légitime et est utilisée 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 étiquettes (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 afin qu'ils apprennent à détecter les fraudes liées à 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 créez et entraînez 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 s'agit du type d'événement sample_registration 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 'EXTERNAL_EVENTS' l'trainingDataSourceemplacement Amazon S3 où vous avez stocké votre exemple de jeu de données et RoleArncelui du compartiment Amazon S3 pourexternalEventsDetail. Pour le trainingDataSchema paramètre, spécifiez la manière dont Amazon Fraud Detector interprète les données d'exemple. Spécifiez plus précisément les variables à inclure et le mode de classification des étiquettes d'é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, le statut de la version du modèle passe àTRAINING_COMPLETE. Vous pouvez consulter le score de performance du modèle et d'autres indicateurs 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 et des indicateurs de performance du modèle. Une fois la formation du modèle terminée, Amazon Fraud Detector valide les performances du modèle en utilisant les 15 % de 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 indicateurs de performance.

Utilisez l'DescribeModelVersionsAPI pour examiner les performances du modèle. Examinez le score global des performances du modèle et tous les autres indicateurs générés par Amazon Fraud Detector pour ce modèle.

Pour en savoir plus sur le score de performance du modèle et les indicateurs de performance, consultez Scores du modèle etIndicateurs de performance du modèle.

Vous pouvez vous attendre à ce que tous les modèles Amazon Fraud Detector que vous avez entraînés disposent de mesures de performance réelles en matière de détection des fraudes, similaires à celles présentées dans ce didacticiel.

Déployer un modèle

Après avoir examiné les indicateurs de performance de votre modèle entraîné, déployez le modèle et mettez-le à la disposition d'Amazon Fraud Detector afin de 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 le statut 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 une 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 BROUILLON, ACTIF ou INACTIF. 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 d'sample_registrationé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 affecté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 par rapport à différents seuils. Il s'agit de déterminer le niveau de risque d'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 du détecteur définit le modèle et les règles utilisés pour prédire les fraudes.

Dans l'exemple suivant, l'CreateDetectorVersionAPI est utilisée pour créer une version du détecteur. Pour ce faire, il fournit les détails de la version du modèle, les règles et un mode d'exécution des règles FIRST_MATCHED. Un mode d'exécution de règles définit la séquence d'évaluation des règles. Le mode d'exécution des règles FIRST_MATCHED indique que les règles sont évaluées séquentiellement, du début à 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 (email_address et ip_address) du fichier d'exemple de données d'enregistrement du 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 :