Cette page a été traduite par l'API Cloud Translation.

Atelier de programmation : prédiction des fraudes et analyse géospatiale pour l'ensemble de données de banque de détail

1. Introduction

Dans cet atelier, vous allez créer un modèle de régression linéaire pour prédire si des transactions récentes sont frauduleuses ou non en utilisant SQL dans BigQuery. Vous allez créer un ensemble de données d'entraînement contenant chaque transaction par carte, et certains des attributs que nous avons identifiés comme étant les plus représentatifs d'une fraude, tels que la distance par rapport au domicile du client, l'heure de la journée et le montant de la transaction.

Vous allez ensuite utiliser BQML pour créer un modèle de régression logistique afin de prédire si une transaction est frauduleuse à partir de nos données d'entraînement. L'une des fonctionnalités intéressantes de BQ ML est qu'il gère le surapprentissage, de sorte que nos données d'entraînement n'ont pas d'incidence sur les performances du modèle sur de nouvelles données. Pour finir, vous allez créer trois exemples de transactions avec des caractéristiques différentes et prédire si elles sont frauduleuses ou si elles n'utilisent pas le modèle.

Objectifs de l'atelier

Dans cet atelier, vous allez apprendre à effectuer les tâches suivantes :

Charger un ensemble de données depuis un bucket Google Cloud Storage
Créer des données d'entraînement
Créer et entraîner un modèle de régression logistique
Utiliser le modèle pour prédire si des exemples de transactions sont frauduleuses ou non
Identifier une transaction frauduleuse par code postal grâce à l'analyse géospatiale

2. Charger un ensemble de données depuis un bucket GCS

Dans cette tâche, vous allez créer un ensemble de données appelé bq_demo et le charger avec des données de banque de détail à partir d'un bucket GCS. Toutes les données existantes qui se trouvent déjà dans vos tables seront supprimées.

Ouvrir Cloud Shell

Dans la barre d'outils située en haut à droite de la console Cloud, cliquez sur le bouton "Activer Cloud Shell".

Une fois la fenêtre Cloud Shell chargée, saisissez la commande suivante:

bq rm -r -f -d bq_demo
bq rm -r -f -d bq_demo_shared
bq mk --dataset bq_demo
bq load --replace --autodetect --source_format=CSV bq_demo.account gs://retail-banking-looker/account
bq load --replace --autodetect --source_format=CSV bq_demo.base_card gs://retail-banking-looker/base_card
bq load --replace --autodetect --source_format=CSV bq_demo.card gs://retail-banking-looker/card
bq load --replace --autodetect --source_format=CSV bq_demo.card_payment_amounts gs://retail-banking-looker/card_payment_amounts
bq load --replace --autodetect --source_format=CSV bq_demo.card_transactions gs://retail-banking-looker/card_transactions
bq load --replace --autodetect --source_format=CSV bq_demo.card_type_facts gs://retail-banking-looker/card_type_facts
bq load --replace --autodetect --source_format=CSV bq_demo.client gs://retail-banking-looker/client
bq load --replace --autodetect --source_format=CSV bq_demo.disp gs://retail-banking-looker/disp
bq load --replace --autodetect --source_format=CSV bq_demo.loan gs://retail-banking-looker/loan
bq load --replace --autodetect --source_format=CSV bq_demo.order gs://retail-banking-looker/order
bq load --replace --autodetect --source_format=CSV bq_demo.trans gs://retail-banking-looker/trans

Une fois que vous avez terminé, cliquez sur la croix (X) pour fermer le terminal Cloud Shell. Vous venez de charger un ensemble de données à partir d'un bucket Google Cloud Storage.

3. Créer des données d'entraînement

Requête concernant les transactions frauduleuses par type de carte

Avant de créer des données d'entraînement, analysons la répartition des transactions frauduleuses entre les types de cartes. Notre base de données de banque de détail contient un drapeau qui indique qu'un client a signalé une transaction frauduleuse sur son compte. Cette requête affiche le nombre de transactions frauduleuses par type de carte.

[Point de discussion concurrentiel : Contrairement à certains concurrents, BigQuery ne nécessite pas d'exporter les données de votre entrepôt de données vers un bucket de stockage, d'exécuter des algorithmes de machine learning, puis de copier les résultats dans la base de données. Tout cela peut être effectué sur place, ce qui préserve la sécurité des données et n'entraîne pas une "prolifération des données".]

Ouvrez la console BigQuery:

Dans la console Google Cloud, sélectionnez le menu de navigation > dans BigQuery.

Le message "Bienvenue sur BigQuery dans la console Cloud" s'affiche. Il contient un lien vers le guide de démarrage rapide et les notes de version.

Cliquez sur "OK".

La console BigQuery s'ouvre.

Exécutez la requête dans l'éditeur de requête:

SELECT c.type, count(trans_id) as fraud_transactions
FROM bq_demo.card_transactions AS t 
JOIN bq_demo.card c ON t.cc_number = c.card_number
WHERE t.is_fraud=1
GROUP BY type

Et si nous pouvions utiliser ces données pour prédire les transactions frauduleuses avant même que le client ne le remarque ? Le ML n'est pas réservé aux experts. Avec BigQuery, les analystes peuvent exécuter des modèles de ML de pointe directement sur des données d'entrepôts de données via SQL.

Créer des données d'entraînement

Créez un ensemble de données d'entraînement contenant chaque transaction par carte et certains des attributs que nous avons identifiés comme étant les plus représentatifs d'une fraude, tels que la distance par rapport au domicile du client, l'heure de la journée et le montant de la transaction.

Exécutez la requête dans l'éditeur de requête:

CREATE OR REPLACE TABLE bq_demo.training_data as (
  SELECT
    card_transactions.trans_id  AS trans_id,
    card_transactions.is_fraud  AS is_fraud,
    --amount for transaction: higher amounts are more likely to be fraud
    cast(card_transactions.amount as FLOAT64)  AS card_transactions_amount,
    --distance from the customers home: further distances are more likely to be fraud
    ST_DISTANCE((ST_GEOGPOINT((cast(card_transactions.merchant_lon as FLOAT64)),
            (cast(card_transactions.merchant_lat as FLOAT64)))), (ST_GeogPoint((cast(SPLIT(client.address,'|')[OFFSET(4)] as float64)),
            (cast(SPLIT(client.address,'|')[OFFSET(3)] as float64)))))  AS card_transactions_transaction_distance,
    --hour that transaction occured: fraud occurs in middle of night (usually between midnight and 4 am)
    EXTRACT(HOUR FROM TIMESTAMP(CONCAT(card_transactions.trans_date,' ',card_transactions.trans_time)) ) AS card_transactions_transaction_hour_of_day
  FROM bq_demo.card_transactions  AS card_transactions
  LEFT JOIN bq_demo.card  AS card ON card.card_number = card_transactions.cc_number
  LEFT JOIN bq_demo.disp  AS disp ON card.disp_id = disp.disp_id
  LEFT JOIN bq_demo.client  AS client ON disp.client_id = client.client_id );

Sous "Résultats" cliquez sur « go to table » (Accéder à la table) Vous devriez obtenir le résultat suivant:

4. Créer et entraîner le modèle

Utiliser BQML pour créer un modèle de régression logistique permettant de prédire si une transaction est frauduleuse à partir des données d'entraînement créées à l'étape précédente. BQML offre une fonctionnalité intéressante : il gère le surapprentissage, de sorte que nos données d'entraînement n'affectent pas les performances du modèle sur de nouvelles données.

Exécutez la requête dans l'éditeur de requête:

CREATE OR REPLACE MODEL bq_demo.fraud_prediction
    OPTIONS(model_type='logistic_reg', labels=['is_fraud']) AS
    SELECT * EXCEPT(trans_id)
    FROM bq_demo.training_data
    WHERE (is_fraud = 1) OR 
            (is_fraud = 0 AND rand() <= 
                (SELECT SUM(is_fraud)/COUNT(*) FROM bq_demo.training_data));

Afficher les détails du modèle

Sous "Résultats", cliquez sur "Accéder au modèle".

Vous devriez voir les onglets "Schéma", "Entraînement" et "Évaluation".

Sous l'onglet "Entraînement", vous devriez voir ceci:

Dans l'onglet "Évaluation", vous devriez voir ceci:

Dans l'onglet "Schéma", vous devriez voir ceci:

5. Utiliser le modèle pour prédire la fraude

Utilisons maintenant notre modèle pour prédire si une transaction est potentiellement frauduleuse. Nous allons créer trois exemples de transactions avec des caractéristiques différentes.

Exécutez la requête suivante dans l'éditeur de requête:

SELECT * FROM ML.PREDICT(MODEL bq_demo.fraud_prediction, (
  SELECT '001' as trans_id, 500.00 as card_transactions_amount, 600 as card_transactions_transaction_distance, 2 as card_transactions_transaction_hour_of_day
    UNION ALL
  SELECT '002' as trans_id, 5.25 as card_transactions_amount, 2 as card_transactions_transaction_distance, 13 as card_transactions_transaction_hour_of_day
    UNION ALL
  SELECT '003' as trans_id, 175.50 as card_transactions_amount, 45 as card_transactions_transaction_distance, 10 as card_transactions_transaction_hour_of_day
  ), STRUCT(0.55 AS threshold)
);

Vous devez obtenir des résultats semblables à ceux-ci :

Comme vous pouvez le constater, la première transaction est presque certainement frauduleuse d'après notre modèle, tandis que les deuxième et troisième transactions sont prédites comme non frauduleuses. Nous avons donc fixé le seuil à 55%, contre 50 % par défaut. Nous pourrions entraîner notre modèle avec des données supplémentaires ou ajouter d'autres attributs pour améliorer la précision.

6. Identifier une transaction frauduleuse par code postal grâce à l'analyse géospatiale

BigQuery offre une compatibilité étendue pour les données géospatiales. Voici un exemple qui utilise la fonction GIS ST_WITHIN pour déterminer le code postal en fonction de la latitude et de la longitude des transactions des marchands, à l'aide d'un ensemble de données public indiquant les limites des codes postaux.

Exécutez le code suivant dans l'éditeur de requête:

WITH trans_by_zip as (
  SELECT
    card_transactions.trans_id,
    zip_code AS merchant_zip,
    city as merchant_city,
    county as merchant_county,
    state_name as merchant_state
  FROM
    bq_demo.card_transactions AS card_transactions,
    bigquery-public-data.geo_us_boundaries.zip_codes AS zip_codes
  WHERE ST_Within(ST_GEOGPOINT((cast(card_transactions.merchant_lon as FLOAT64)),(cast(card_transactions.merchant_lat as FLOAT64))),zip_codes.zip_code_geom)
)
SELECT merchant_zip, 1.0 * (SUM(is_fraud)) / nullif((COUNT(*)),0) AS percent_transactions_fraud
FROM bq_demo.card_transactions t, trans_by_zip
WHERE t.trans_id = trans_by_zip.trans_id
GROUP BY merchant_zip
ORDER BY percent_transactions_fraud DESC;

Vous devriez obtenir les résultats suivants:

Comme vous pouvez le constater, le taux de fraude dans la plupart des codes postaux est relativement faible (inférieur à 2%), mais le taux de fraude en 69345 est surprenant de 11%. C'est probablement quelque chose que nous voulons étudier.