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.
# Commencez avec Amazon Fraud Detector
Avant de commencer, assurez-vous d'avoir lu [Détecter les fraudes avec Amazon Fraud Detector](frauddetector-workflow.md) et terminé les étapes de saisie[Configurer Amazon Fraud Detector](set-up.md).
Utilisez les didacticiels pratiques de cette section pour découvrir comment utiliser Amazon Fraud Detector pour créer, former et déployer un modèle de détection des fraudes. Dans ce didacticiel, vous incarnez un analyste des fraudes utilisant un modèle d'apprentissage automatique pour prédire si l'enregistrement d'un nouveau compte est frauduleux. Le modèle doit être entraîné à l'aide des données issues des enregistrements de comptes. Amazon Fraud Detector fournit un exemple de jeu de données d'enregistrement de compte pour ce didacticiel. L'exemple de jeu de données doit être chargé avant que vous ne commenciez le didacticiel.
Vous pouvez commencer à utiliser Amazon Fraud Detector en utilisant l'une des interfaces suivantes. Avant de commencer le didacticiel, assurez-vous de suivre les instructions pour [Obtenir et télécharger un exemple de jeu de données](step-1-get-s3-data.md)
+ [Tutoriel : Commencez à utiliser la console Amazon Fraud Detector](get-started-console.md)
+ [Tutoriel : Commencez à utiliser le AWS SDK pour Python (Boto3)](getting-started-python.md)
# Obtenir et télécharger un exemple de jeu de données
L'exemple de jeu de données que vous utilisez dans ce didacticiel fournit des détails sur les enregistrements de comptes en ligne. L'ensemble de données se trouve dans un fichier texte qui utilise des valeurs séparées par des virgules (CSV) au format UTF-8. La première ligne du fichier de données CSV contient les en-têtes. La ligne d'en-tête est suivie de plusieurs lignes de données. Chacune de ces lignes contient des éléments de données provenant de l'enregistrement d'un seul compte. Les données sont étiquetées pour votre commodité. Une colonne de l'ensemble de données indique si l'enregistrement du compte est frauduleux.
**Pour obtenir et télécharger un exemple de jeu de données**
1. Accédez à [Samples](https://github.com/aws-samples/aws-fraud-detector-samples/tree/master/data).
Deux fichiers de données contiennent des données d'enregistrement de compte en ligne : *registration\$1data\$120K\$1minimum.csv* et *registration\$1data\$120K\$1full.csv*. *Le fichier ne `registration_data_20K_minimum` contient que deux variables : *ip\$1address et email\$1address*.* Le fichier `registration_data_20K_full` contient d'autres variables. *Ces variables concernent chaque événement et incluent *billing\$1address, phone\$1number* *et user\$1agent*.* Les deux fichiers de données contiennent également deux champs obligatoires :
+ EVENT\$1TIMESTAMP — Définit le moment où l'événement s'est produit
+ EVENT\$1LABEL — Classe l'événement comme frauduleux ou légitime
Vous pouvez utiliser l'un des deux fichiers pour ce didacticiel. Téléchargez le fichier de données que vous souhaitez utiliser.
1. Créez un compartiment Amazon Simple Storage Service (Amazon S3).
Au cours de cette étape, vous créez un stockage externe pour stocker le jeu de données. Ce stockage externe est un bucket Amazon S3. Pour plus d'informations sur Amazon S3, consultez [Qu'est-ce qu'Amazon S3 ?](https://docs.aws.amazon.com/AmazonS3/latest/userguide/Welcome.html)
1. Connectez-vous à la console Amazon S3 AWS Management Console et ouvrez-la à l'adresse [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).
1. Dans **Buckets**, choisissez **Create bucket.**
1. Pour **Nom du compartiment**, saisissez un nom de compartiment. Assurez-vous de suivre les règles de dénomination des compartiments dans la console et de fournir un nom unique au monde. Nous vous recommandons d'utiliser un nom qui décrit l'objectif du bucket.
1. Pour **Région AWS**, choisissez l' Région AWS endroit où vous souhaitez créer votre bucket. La région que vous choisissez doit prendre en charge Amazon Fraud Detector. Pour réduire le temps de latence, choisissez Région AWS celui qui est le plus proche de votre position géographique. Pour obtenir la liste des régions qui prennent en charge Amazon Fraud Detector, consultez le [tableau des régions](https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/) du *Global Infrastructure Guide*.
1. Conservez les paramètres par défaut pour la **propriété de l'objet**, **les paramètres du compartiment pour le blocage de l'accès public**, le **versionnement des** compartiments et les **balises** pour ce didacticiel.
1. Pour le **chiffrement par défaut**, choisissez **Désactiver** pour ce didacticiel.
1. Vérifiez la configuration de votre compartiment, puis choisissez **Create bucket**.
1. Téléchargez un exemple de fichier de données dans le compartiment Amazon S3.
Maintenant que vous disposez d'un compartiment, chargez l'un des fichiers d'exemple que vous avez précédemment téléchargés dans le compartiment Amazon S3 que vous venez de créer.
1. Dans les **compartiments**, le nom de votre compartiment est répertorié. Choisissez votre compartiment.
1. Choisissez **Charger**.
1. Dans **Fichiers et dossiers**, choisissez **Ajouter des fichiers**.
1. Choisissez l'un des exemples de fichiers de données que vous avez téléchargés sur votre ordinateur, puis choisissez **Ouvrir**.
1. Conservez les paramètres par défaut pour **Destination**, **Autorisations** et **Propriétés**.
1. Passez en revue les configurations, puis choisissez **Upload**.
1. Le fichier de données d'exemple est chargé dans le compartiment Amazon S3. Notez l'emplacement du compartiment. Dans la section **Objets**, choisissez l'exemple de fichier de données que vous venez de télécharger.
1. Dans la **vue d'ensemble de l'objet**, copiez l'emplacement sous l'**URI S3**. Il s'agit de l'emplacement Amazon S3 de votre fichier de données d'exemple. Tu l'utiliseras plus tard. Vous pouvez également copier l'**Amazon Resource Name (ARN)** de votre compartiment S3 et l'enregistrer.
# Tutoriel : Commencez à utiliser la console Amazon Fraud Detector
Ce didacticiel se compose de deux parties. La première partie décrit comment créer, former et déployer un modèle de détection des fraudes. La deuxième partie explique comment utiliser le modèle pour générer des prévisions de fraude en temps réel. Le modèle est entraîné à l'aide du fichier de données d'exemple que vous téléchargez dans un compartiment 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
**Important**
Avant de poursuivre, assurez-vous d'avoir suivi les instructions [Obtenir et télécharger un exemple de jeu de données](step-1-get-s3-data.md)
# Partie A : Création, formation et déploiement d'un modèle Amazon Fraud Detector
Dans la partie A, vous définissez votre cas d'utilisation métier, définissez votre événement, créez un modèle, entraînez le modèle, évaluez les performances du modèle et déployez le modèle.
## Étape 1 : Choisissez votre cas d'utilisation professionnel
+ Au cours de cette étape, vous utilisez l'**explorateur de modèles de données** pour faire correspondre votre cas d'utilisation commercial aux types de modèles de détection des fraudes pris en charge par Amazon Fraud Detector. L'explorateur de modèles de données est un outil intégré à la console Amazon Fraud Detector qui recommande un type de modèle à utiliser pour créer et entraîner un modèle de détection des fraudes adapté à votre cas d'utilisation professionnelle. L'explorateur de modèles de données fournit également des informations sur les éléments de données obligatoires, recommandés et facultatifs que vous devrez inclure dans votre ensemble de données. L'ensemble de données sera utilisé pour créer et entraîner votre modèle de détection des fraudes.
Dans le cadre de ce didacticiel, votre cas d'utilisation professionnelle concerne l'enregistrement de nouveaux comptes. Après avoir défini votre cas d'utilisation métier, l'explorateur de modèles de données vous recommandera un type de modèle pour créer un modèle de détection des fraudes et vous fournira également une liste des éléments de données dont vous aurez besoin pour créer votre ensemble de données. Comme vous avez déjà chargé un exemple de jeu de données contenant des données provenant de nouveaux enregistrements de comptes, il n'est pas nécessaire de créer un nouvel ensemble de données.
1. Ouvrez la [console de gestion AWS](https://console.aws.amazon.com/) et connectez-vous à votre compte. Accédez à Amazon Fraud Detector.
1. Dans le volet de navigation de gauche, choisissez **Data models explorer**.
1. Sur la page **Explorateur de modèles de données**, sous **Cas d'utilisation professionnel**, sélectionnez **Nouveau compte frauduleux**.
1. Amazon Fraud Detector affiche le type de modèle recommandé à utiliser pour créer un modèle de détection des fraudes adapté au cas d'utilisation commerciale sélectionné. Le type de modèle définit les algorithmes, les enrichissements et les transformations qu'Amazon Fraud Detector utilisera pour entraîner votre modèle de détection des fraudes.
Prenez note du type de modèle recommandé. Vous en aurez besoin ultérieurement lors de la création de votre modèle.
1. Le volet **Informations sur le modèle de données** fournit un aperçu des éléments de données obligatoires et recommandés nécessaires pour créer et entraîner un modèle de détection des fraudes.
Examinez l'exemple de jeu de données que vous avez téléchargé et assurez-vous qu'il contient tous les éléments de données obligatoires et certains éléments de données recommandés répertoriés dans le tableau.
Plus tard, lorsque vous créerez un modèle pour votre cas d'utilisation commercial spécifique, vous utiliserez les informations fournies pour créer votre ensemble de données.
## Étape 2 : Création d'un type d'événement
+ Au cours de cette étape, vous définissez l'activité commerciale (événement) à évaluer pour détecter la fraude. La définition de l'événement implique de définir les variables présentes dans votre ensemble de données, l'entité à l'origine de l'événement et les étiquettes qui classent l'événement. Dans ce didacticiel, vous définissez l'événement d'enregistrement du compte.
1. Ouvrez la [console de gestion AWS](https://console.aws.amazon.com/) et connectez-vous à votre compte. Accédez à Amazon Fraud Detector.
1. Dans le volet de navigation de gauche, sélectionnez **Events**.
1. Sur la page **Type d'événements**, choisissez **Create**.
1. Sous **Détails du type d'événement**, entrez le `sample_registration` nom du type d'événement et, éventuellement, entrez une description de l'événement.
1. Pour **Entité**, choisissez **Créer une entité**.
1. Sur la page **Créer une entité**, entrez le `sample_customer` nom du type d'entité. Entrez éventuellement une description du type d'entité.
1. Choisissez **Create entity** (Créer une entité).
1. Sous **Variables d'événement**, pour **Choisir comment définir les variables de cet événement**, choisissez **Sélectionner les variables d'un jeu de données d'entraînement**.
1. Pour le **rôle IAM**, choisissez **Create IAM** role.
1. Sur la page **Créer un rôle IAM**, entrez le nom du compartiment S3 dans lequel vous avez chargé vos exemples de données et choisissez **Create role**.
1. Dans **Emplacement des données**, entrez le chemin d'accès à vos exemples de données. Il s'agit du `S3 URI` chemin que vous avez enregistré après avoir chargé les données d'exemple. Le chemin est similaire à celui-ci :`S3://your-bucket-name/example dataset filename.csv`.
1. Choisissez **Charger**.
Amazon Fraud Detector extrait les en-têtes de votre fichier de données d'exemple et les associe à un type de variable. Le mappage s'affiche dans la console.
1. Sous **Étiquettes - facultatif**, pour **Étiquettes**, choisissez **Créer de nouvelles étiquettes**.
1. Dans la page **Créer une étiquette**, entrez le `fraud` nom. Cette étiquette correspond à la valeur qui représente l'enregistrement frauduleux du compte dans l'exemple de jeu de données.
1. Choisissez **Créer une étiquette**.
1. Créez une deuxième étiquette, puis `legit` saisissez-la comme nom. Cette étiquette correspond à la valeur qui représente l'enregistrement légitime du compte dans l'exemple de jeu de données.
1. Choisissez **Créer un type d'événement**.
## Étape 3 : Création du modèle
1. Sur la page **Modèles**, choisissez **Ajouter un modèle**, puis **Créer un modèle**.
1. Pour **l'étape 1 — Définir les détails du modèle**, entrez le `sample_fraud_detection_model` nom du modèle. Ajoutez éventuellement une description du modèle.
1. Pour le **type de modèle**, choisissez le modèle **Online Fraud Insights**.
1. Pour **Type d'événement**, choisissez **sample\$1registration**. Il s'agit du type d'événement que vous avez créé à l'étape 1.
1. Dans **Données historiques sur les événements**,
1. Dans **Source de données d'événements**, choisissez **Données d'événements stockées dans S3**.
1. Pour le **rôle IAM**, sélectionnez le rôle que vous avez créé à l'étape 1.
1. Dans **Emplacement des données d'entraînement**, entrez le chemin de l'URI S3 vers votre exemple de fichier de données.
1. Choisissez **Suivant**.
## Étape 4 : Modèle de train
1. Dans les **entrées du modèle**, laissez toutes les cases cochées. Par défaut, Amazon Fraud Detector utilise toutes les variables de votre ensemble de données d'événements historiques comme entrées de modèle.
1. Dans **Classification des étiquettes**, pour les **étiquettes de fraude**, choisissez **fraude** car cette étiquette correspond à la valeur qui représente les événements frauduleux dans l'exemple de jeu de données. Pour les **étiquettes légitimes**, choisissez **legit** car cette étiquette correspond à la valeur qui représente les événements légitimes dans l'exemple de jeu de données.
1. Pour le **traitement des événements non étiquetés**, conservez la sélection par défaut **Ignorer les événements non étiquetés** pour cet exemple de jeu de données.
1. Choisissez **Suivant**.
1. Après avoir vérifié, choisissez **Créer et entraîner le modèle**. Amazon Fraud Detector crée un modèle et commence à en entraîner une nouvelle version.
Dans **les versions du modèle**, la colonne **État** indique l'état de l'entraînement du modèle. L'entraînement du modèle qui utilise l'exemple de jeu de données prend environ 45 minutes. Le statut passe à **Prêt pour le déploiement** une fois la formation du modèle terminée.
# Étape 5 : Examiner les performances du modèle
L'une des étapes importantes 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 et génère un score de performance du modèle ainsi que d'autres indicateurs de performance.
1. Pour voir les performances du modèle,
1. Dans le volet de navigation de gauche de la console Amazon Fraud Detector, sélectionnez **Models**.
1. **Sur la page **Modèles**, choisissez le modèle que vous venez d'entraîner (**sample\$1fraud\$1detection\$1model), puis** choisissez 1.0.** Il s'agit de la version créée par Amazon Fraud Detector à partir de votre modèle.
1. 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 présentés sur cette page, 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 possèdent des indicateurs de performance réels en matière de détection des fraudes similaires à ceux présentés pour le modèle dans ce didacticiel.
# Étape 6 : Déployer le modèle
Une fois que vous avez examiné les indicateurs de performance de votre modèle entraîné et que vous êtes prêt à l'utiliser pour générer des prévisions de fraude, vous pouvez déployer le modèle.
1. Dans le volet de navigation gauche de la console Amazon Fraud Detector, sélectionnez **Models**.
1. Sur la page **Modèles**, choisissez **sample\$1fraud\$1detection\$1model, puis choisissez la version du modèle** spécifique que vous souhaitez déployer. Pour ce didacticiel, choisissez **1.0**.
1. Sur la page **Version du modèle**, sélectionnez **Actions**, puis choisissez **Déployer la version du modèle**.
1. Dans les **versions du modèle**, le **statut** indique l'état du déploiement. Le statut passe à **Actif** une fois le déploiement terminé. Cela indique que la version du modèle est activée et disponible pour générer des prévisions de fraude. Continuez [Partie B : Générer des prévisions de fraude](part-b.md) pour suivre les étapes permettant de générer des prévisions de fraude.
# Partie B : Générer des prévisions de fraude
La prédiction des fraudes est une évaluation de la fraude dans le cadre d'une activité commerciale (événement). Amazon Fraud Detector utilise des détecteurs pour générer des prévisions de fraude. Un détecteur contient une logique de détection, telle que des modèles et des règles, pour un événement spécifique que vous souhaitez évaluer pour détecter une fraude. La logique de détection utilise des règles pour indiquer à Amazon Fraud Detector comment interpréter les données associées au modèle. Dans ce didacticiel, vous allez évaluer l'événement d'enregistrement du compte à l'aide de l'exemple de jeu de données d'enregistrement de compte que vous avez chargé précédemment.
Dans la partie A, vous avez créé, entraîné et déployé votre modèle. Dans la partie B, vous créez un détecteur pour le type d'`sample_registration`événement, vous ajoutez le modèle déployé, vous créez des règles et un ordre d'exécution des règles, puis vous créez et activez une version du détecteur que vous utilisez pour générer des prévisions de fraude.
## Étape 1 : Construire un détecteur
**Pour créer un détecteur**
1. Dans le volet de navigation de gauche de la console Amazon Fraud Detector, choisissez **Detectors**.
1. Choisissez **Créer un détecteur**.
1. Sur la page **Définir les détails du détecteur**, entrez `sample_detector` le nom du détecteur. Entrez éventuellement une description du détecteur, telle que`my sample fraud detector`.
1. Pour **Type d'événement**, sélectionnez **sample\$1registration**. Il s'agit de l'événement que vous avez créé dans la partie A de ce didacticiel.
1. Choisissez **Suivant**.
## Étape 2 : Ajouter un modèle
Si vous avez terminé la partie A de ce didacticiel, vous disposez probablement déjà d'un modèle Amazon Fraud Detector que vous pouvez ajouter à votre détecteur. Si vous n'avez pas encore créé de modèle, passez à la partie A et suivez les étapes de création, de formation et de déploiement d'un modèle, puis passez à la partie B.
1. Dans le champ **Ajouter un modèle (facultatif)**, sélectionnez **Ajouter un modèle**.
1. Sur la page **Ajouter un modèle**, pour **Sélectionner un modèle**, choisissez le nom du modèle Amazon Fraud Detector que vous avez déployé précédemment. Pour **Sélectionner une version**, choisissez la version du modèle déployé.
1. Choisissez **Add model**.
1. Choisissez **Suivant**.
## Étape 3 : Ajouter des règles
Une règle est une condition qui indique à Amazon Fraud Detector comment interpréter le score de performance d'un modèle lors d'une évaluation visant à prédire les fraudes. Dans le cadre de ce didacticiel, vous allez créer trois règles : `high_fraud_risk``medium_fraud_risk`, et`low_fraud_risk`.
1. Sur la page **Ajouter des règles**, sous **Définir une règle**, entrez `high_fraud_risk` le nom de la règle et sous **Description (facultatif)**, entrez **This rule captures events with a high ML model score** la description de la règle.
1. Dans **Expression, entrez l'expression** de règle suivante en utilisant le langage d'expression de règles simplifié d'Amazon Fraud Detector :
`$sample_fraud_detection_model_insightscore > 900`
1. Dans **Résultats**, choisissez **Créer un nouveau résultat**. Un résultat est le résultat d'une prédiction de fraude et est renvoyé si la règle correspond lors d'une évaluation.
1. Dans **Créer un nouveau résultat**, entrez le `verify_customer` nom du résultat. Entrez éventuellement une description.
1. Choisissez **Enregistrer le résultat**.
1. Choisissez **Ajouter une règle** pour exécuter le vérificateur de validation des règles et enregistrer la règle. Une fois la règle créée, Amazon Fraud Detector met la règle à disposition de votre détecteur.
1. Choisissez **Ajouter une autre règle**, puis cliquez sur l'onglet **Créer une règle**.
1. Répétez ce processus deux fois de plus pour créer vos `low_fraud_risk` règles `medium_fraud_risk` and à l'aide des détails suivants :
+ risque\$1de\$1fraude moyen
Nom de la règle : `medium_fraud_risk`
Résultat : `review`
Expression :
`$sample_fraud_detection_model_insightscore <= 900 and`
`$sample_fraud_detection_model_insightscore > 700`
+ faible risque de fraude
Nom de la règle : `low_fraud_risk`
Résultat : `approve`
Expression :
`$sample_fraud_detection_model_insightscore <= 700`
Ces valeurs sont des exemples utilisés pour ce didacticiel. Lorsque vous créez des règles pour votre propre détecteur, utilisez des valeurs adaptées à votre modèle et à votre cas d'utilisation,
1. Après avoir créé les trois règles, choisissez **Next**.
Pour plus d'informations sur la création et la rédaction de règles, reportez-vous aux [Rules](rules.md) sections et[Référence du langage des règles](rule-language-reference.md).
## Étape 4 : Configuration de l'exécution et de l'ordre des règles
Le mode d'exécution des règles incluses dans le détecteur détermine si toutes les règles que vous définissez sont évaluées ou si l'évaluation des règles s'arrête à la première règle correspondante. Et l'ordre des règles détermine l'ordre dans lequel vous souhaitez que la règle soit exécutée.
Le mode d'exécution des règles par défaut est`FIRST_MATCHED`.
**Premier appariement**
Le mode d'exécution de la première règle correspondante renvoie les résultats de la première règle correspondante en fonction de l'ordre des règles défini. Si vous spécifiez `FIRST_MATCHED`, Amazon Fraud Detector évalue les règles de manière séquentielle, de la première à la dernière, en s'arrêtant à la première règle correspondante. Amazon Fraud Detector fournit ensuite les résultats pour cette seule règle.
L'ordre dans lequel vous exécutez les règles peut avoir une incidence sur le résultat de la prédiction des fraudes. Après avoir créé vos règles, réorganisez-les pour les exécuter dans l'ordre souhaité en procédant comme suit :
Si votre `high_fraud_risk` règle ne figure pas déjà en haut de votre liste de règles, choisissez **Ordre**, puis choisissez **1**. Cela passe `high_fraud_risk` à la première position.
Répétez ce processus pour que votre `medium_fraud_risk` règle soit en deuxième position et votre `low_fraud_risk` règle en troisième position.
**Tous assortis**
Le mode d'exécution de toutes les règles correspondantes renvoie les résultats pour toutes les règles correspondantes, quel que soit l'ordre des règles. Si vous le spécifiez`ALL_MATCHED`, Amazon Fraud Detector évalue toutes les règles et renvoie les résultats pour toutes les règles correspondantes.
Sélectionnez `FIRST_MATCHED` ce didacticiel, puis cliquez sur **Suivant**.
# Étape 5 : révision et création de la version du détecteur
Une version du détecteur définit les modèles et règles spécifiques utilisés pour générer des prédictions de fraude.
1. Sur la page **Réviser et créer**, passez en revue les détails du détecteur, les modèles et les règles que vous avez configurés. Si vous devez apporter des modifications, choisissez **Modifier** à côté de la section correspondante.
1. Choisissez **Créer un détecteur**. Une fois créée, la première version de votre détecteur apparaît dans le tableau des versions du détecteur avec `Draft` son état.
Vous utilisez la version **Brouillon** pour tester votre détecteur.
# Étape 6 : Tester et activer la version du détecteur
Dans la console Amazon Fraud Detector, vous pouvez tester la logique de votre détecteur à l'aide de données fictives grâce à la fonctionnalité **Run test**. Pour ce didacticiel, vous pouvez utiliser les données d'enregistrement de compte issues de l'exemple de jeu de données.
1. Faites défiler la page jusqu'à **Exécuter le test** en bas de la page de **détails de la version du détecteur**.
1. Pour les **métadonnées d'événement**, entrez un horodatage indiquant le moment où l'événement s'est produit et entrez un identifiant unique pour l'entité qui réalise l'événement. Pour ce didacticiel, sélectionnez une date dans le sélecteur de date pour l'horodatage et entrez « 1234 » pour l'ID d'entité.
1. Pour **Variable d'événement**, entrez les valeurs des variables que vous souhaitez tester. Pour ce didacticiel, vous n'avez besoin que `ip_address` des `email_address` champs et. En effet, ce sont les entrées qui sont utilisées pour entraîner votre modèle Amazon Fraud Detector. Vous pouvez utiliser les exemples de valeurs suivants. Cela suppose que vous avez utilisé les noms de variables suggérés :
+ adresse\$1IP : `205.251.233.178`
+ adresse\$1e-mail : `johndoe@exampledomain.com`
1. Choisissez **Exécuter un test**.
1. Amazon Fraud Detector renvoie le résultat de la prédiction des fraudes en fonction du mode d'exécution des règles. Si le mode d'exécution de la règle est activé`FIRST_MATCHED`, le résultat renvoyé correspond à la première règle correspondante. La première règle est celle qui a la priorité la plus élevée. Il correspond s'il est évalué comme vrai. Si le mode d'exécution des règles est activé`ALL_MATCHED`, le résultat renvoyé correspond à toutes les règles correspondantes. Cela signifie qu'ils sont tous évalués comme étant vrais. Amazon Fraud Detector renvoie également le score du modèle pour tous les modèles ajoutés à votre détecteur.
Vous pouvez modifier les entrées et exécuter quelques tests pour obtenir des résultats différents. Vous pouvez utiliser les valeurs *ip\$1address* et *email\$1address* de votre exemple de jeu de données pour les tests et vérifier si les résultats sont conformes aux attentes.
1. Lorsque vous êtes satisfait du fonctionnement du détecteur, promouvez-le de `Draft` à`Active`. Cela rend le détecteur disponible pour une utilisation dans le cadre de la détection des fraudes en temps réel.
Sur la page des **détails de la version du détecteur**, choisissez **Actions**, **Publier**, **Publier la version**. Cela fait passer le statut du détecteur de **brouillon** à **actif.**
À ce stade, votre modèle et la logique de détection associée sont prêts à évaluer les activités en ligne pour détecter la fraude en temps réel à l'aide de l'`GetEventPrediction`API Amazon Fraud Detector. Vous pouvez également évaluer les événements hors ligne à l'aide d'un fichier d'entrée CSV et de l'`CreateBatchPredictionJob`API. Pour plus d'informations sur la prévision des fraudes, voir [Prédictions de fraude](getting-fraud-predictions.md)
En suivant 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.
+ Création et formation d'un modèle de détection des fraudes Amazon Fraud Detector à 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.
+ 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.
+ J'ai activé le détecteur en le publiant.
# Tutoriel : Commencez à utiliser le AWS SDK pour Python (Boto3)
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
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
### Étape 1 : Configuration et vérification de votre environnement Python
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
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'[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 = ''
)
#Create variable ip_address
fraudDetector.create_variable(
name = 'ip_address',
variableType = 'IP_ADDRESS',
dataSource = 'EVENT',
dataType = 'STRING',
defaultValue = ''
)
```
#### 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, [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
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
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
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
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\$1MATCHED. 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\$1MATCHED 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
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\$1address et ip\$1address) 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)
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.
# Étapes suivantes
Maintenant que vous avez créé un modèle et un détecteur, vous pouvez approfondir vos connaissances et commencer à créer des modèles et des détecteurs et à générer des prévisions de fraude.
Les sections suivantes du guide de l'utilisateur d'Amazon Fraud Detector décrivent comment votre entreprise ou organisation peut utiliser Amazon Fraud Detector pour détecter les fraudes.
+ Préparez et créez votre ensemble de données d'événements pour entraîner votre modèle.
+ Créer un type d'événement
+ Créer un modèle
+ Créer un détecteur
+ Obtenez des prévisions de fraude
+ Gérez vos ressources Amazon Fraud Detector (en particulier les variables, les entités, les résultats et les étiquettes)
+ Configurez Amazon Fraud Detector pour atteindre vos objectifs de sécurité et de conformité
+ Surveillez Amazon Fraud Detector et enregistrez les appels d'API Amazon Fraud Detector
+ Résoudre les problèmes liés à Amazon Fraud Detector