Amazon Fraud Detector n'est plus ouvert aux nouveaux clients depuis le 7 novembre 2025. Pour des fonctionnalités similaires à Amazon Fraud Detector, explorez Amazon SageMaker AutoGluon, et AWS WAF.

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Tutoriel : Commencez à utiliser le AWS SDK pour Python (Boto3)
<a name="getting-started-python"></a>

Ce didacticiel explique comment créer et entraîner un modèle Amazon Fraud Detector, puis comment utiliser ce modèle pour générer des prédictions de fraude en temps réel à l'aide du AWS SDK pour Python (Boto3). Le modèle est entraîné à l'aide du fichier d'exemple de données d'enregistrement du compte que vous téléchargez dans le compartiment Amazon S3.

À la fin de ce didacticiel, vous aurez effectué les actions suivantes :
+ Créez et entraînez un modèle Amazon Fraud Detector
+ Générez des prévisions de fraude en temps réel

## Conditions préalables
<a name="gs-sdk-prerequisites"></a>

Les étapes requises pour ce didacticiel sont les suivantes.
+ Terminé[Configurer Amazon Fraud Detector](set-up.md). 

  Si vous l'avez déjà fait[Configurer le AWS SDK](set-up.md#set-up-sdk), assurez-vous que vous utilisez la version 1.14.29 ou supérieure du SDK Boto3.
+ J'ai suivi les instructions pour le [Obtenir et télécharger un exemple de jeu de données](step-1-get-s3-data.md) fichier requis pour ce didacticiel. 

## Mise en route
<a name="get-started-python"></a>

### Étape 1 : Configuration et vérification de votre environnement Python
<a name="setup-and-verify-your-python-environment"></a>

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).](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html)

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

### Étape 2 : Création de variables, de types d'entités et d'étiquettes
<a name="create-variables-entity-type-and-labels"></a>

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
<a name="create-variable-gs-sdk"></a>

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'[CreateVariable](https://docs.aws.amazon.com//frauddetector/latest/api/API_CreateVariable.html)API est utilisée pour créer deux variables. Les variables sont `email_address` et`ip_address`. Affectez-les aux types de variables correspondants : `EMAIL_ADDRESS` et`IP_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é
<a name="create-entity-gs-sdk"></a>

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, [PutEntityType](https://docs.aws.amazon.com//frauddetector/latest/api/API_PutEntityType.html)l'API est utilisée pour créer un type d'`sample_customer`entité.

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

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

#### Créer une étiquette
<a name="create-label-gs-sdk"></a>

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](https://docs.aws.amazon.com//frauddetector/latest/api/API_PutLabel.html) est utilisée pour créer deux étiquettes, `fraud` et`legit`.

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

### Étape 3 : Création d'un type d'événement
<a name="python-create-event-type"></a>

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'[PutEventType](https://docs.aws.amazon.com//frauddetector/latest/api/API_PutEventType.html)API est utilisée pour créer un type d'événement`sample_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'])
```

### Étape 4 : Création, formation et déploiement du modèle
<a name="python-create-and-train-a-model"></a>

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'appelle`sample_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, consultez[Choisissez un type de modèle](choosing-model-type.md).

**Création d’un modèle**

Dans l'exemple suivant, l'[CreateModel](https://docs.aws.amazon.com//frauddetector/latest/api/API_CreateModel.html)API 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'[CreateModelVersion](https://docs.aws.amazon.com//frauddetector/latest/api/API_CreateModelVersion.html)API est utilisée pour entraîner le modèle. Spécifiez `'EXTERNAL_EVENTS'` l'`trainingDataSource`emplacement Amazon S3 où vous avez stocké votre exemple de jeu de données et *RoleArn*celui du compartiment Amazon S3 pour`externalEventsDetail`. 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'[DescribeModelVersions](https://docs.aws.amazon.com//frauddetector/latest/api/API_DescribeModelVersions.html)API 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](model-scores.md) et[Indicateurs de performance du modèle](training-performance-metrics.md).

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'[UpdateModelVersionStatus](https://docs.aws.amazon.com//frauddetector/latest/api/API_UpdateModelVersionStatus.html)API. 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'
)
```

### Étape 5 : Création du détecteur, des résultats, des règles et de la version du détecteur
<a name="python-create-a-detector-outcome-rules-and-detector-version"></a>

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'[PutDetector](https://docs.aws.amazon.com//frauddetector/latest/api/API_PutDetector.html)API 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'[PutOutcome](https://docs.aws.amazon.com//frauddetector/latest/api/API_PutOutcome.html)API est utilisée pour créer trois résultats : `verify_customer``review`, et`approve`. 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'[CreateRule](https://docs.aws.amazon.com//frauddetector/latest/api/API_CreateRule.html)API est utilisée pour créer trois règles différentes : `high_risk``medium_risk`, et`low_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'[CreateDetectorVersion](https://docs.aws.amazon.com//frauddetector/latest/api/API_CreateDetectorVersion.html)API 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'
)
```

### Étape 6 : Générez des prévisions de fraude
<a name="python-generate-fraud-predictions"></a>

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'[GetEventPrediction](https://docs.aws.amazon.com//frauddetector/latest/api/API_GetEventPrediction.html)API 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 :
+ Un exemple de jeu de données d'événements a été chargé sur Amazon S3.
+ Variables, entités et étiquettes créées qui sont utilisées pour créer et entraîner un modèle.
+ Création et entraînement d'un modèle à l'aide de l'exemple de jeu de données.
+ J'ai consulté le score de performance du modèle et les autres indicateurs de performance générés par Amazon Fraud Detector.
+ Déploiement du modèle de détection des fraudes.
+ Création d'un détecteur et ajout du modèle déployé.
+ Les règles, l'ordre d'exécution des règles et les résultats ont été ajoutés au détecteur.
+ Version du détecteur créée.
+ J'ai testé le détecteur en fournissant différentes entrées et en vérifiant si les règles et l'ordre d'exécution des règles fonctionnaient comme prévu.

## (Facultatif) Explorez l'Amazon Fraud Detector APIs avec un bloc-notes Jupyter (iPython)
<a name="gs-jupyter-notebook"></a>

Pour plus d'exemples d'utilisation d'Amazon Fraud Detector APIs, consultez le [aws-fraud-detector-samples GitHub référentiel](https://github.com/aws-samples/aws-fraud-detector-samples). Les sujets abordés dans les carnets incluent à la fois la création de modèles et de détecteurs à l'aide d'Amazon Fraud Detector APIs et l'envoi de demandes de prédiction de fraudes par lots à l'aide de l'`GetEventPrediction`API.