Betrugserkennung mit BigQuery Graph

1. Einführung

Marketing Header - Fraud in Fintech

Betrügerische Aktivitäten umfassen oft versteckte Netzwerke verbundener Entitäten, z. B. mehrere Konten, die dieselbe E-Mail-Adresse, Telefonnummer oder Postanschrift verwenden. Herkömmliche relationale Datenbanken können diese komplexen Beziehungen mit mehreren Hops nur schwer effizient abfragen.

Mit BigQuery Graph können Sie diese Netzwerke mithilfe von Graphdatenbanken in großem Umfang analysieren. Sie können einen Eigenschaftsgraphen über Ihren vorhandenen BigQuery-Tabellen definieren und die Graph Query Language (GQL) verwenden, um Muster in Ihren Daten zu finden.

Eine gängige Anwendung von Graphnetzwerken zur Betrugserkennung ist das Stoppen von Bestellungen, deren Lieferadresse mit einem Betrugsnetzwerk in Verbindung steht, oder das Stoppen von Zahlungen, die zu einem Betrugsnetzwerk gehören .

In diesem Codelab erstellen Sie eine Lösung zur Betrugserkennung mit BigQuery Graph. Sie laden Daten aus Cloud Storage, erstellen einen Eigenschaftsgraphen und verwenden Graphabfragen, um verdächtige Verbindungen zu identifizieren.

Lerninhalte

  • BigQuery-Dataset erstellen und Daten laden
  • Eigenschaftsgraphen mit DDL definieren
  • Wie Sie den Graphen mit GQL abfragen.
  • So verwenden Sie die Graphanalyse, um Betrug zu erkennen.

Voraussetzungen

  • Google Cloud-Projekt mit aktivierter Abrechnungsfunktion.
  • Eine BigQuery-Notebook-Umgebung (BigQuery Studio oder Colab Enterprise).

Kosten

In diesem Lab werden kostenpflichtige Google Cloud-Ressourcen verwendet. Die geschätzten Kosten liegen unter 5 $, sofern Sie die Ressourcen nach Abschluss löschen.

2. Hinweis

Google Cloud-Projekt auswählen oder erstellen

  1. Wählen Sie in der Google Cloud Console auf der Seite zur Projektauswahl ein Google Cloud-Projekt aus oder erstellen Sie ein Google Cloud-Projekt.
  2. Die Abrechnung für das Google Cloud-Projekt muss aktiviert sein. So prüfen Sie, ob die Abrechnung aktiviert ist

Umgebung auswählen

Für dieses Lab benötigen Sie eine Notebook-Umgebung. Sie können BigQuery Studio oder Colab Enterprise verwenden.

  1. Rufen Sie in der Google Cloud Console die Seite BigQuery auf.
  2. Sie verwenden das Python-Notebook, um die Graphabfragen auszuführen.

Cloud Shell starten

  1. Klicken Sie oben in der Google Cloud Console auf Cloud Shell aktivieren.
  2. Authentifizierung prüfen:
gcloud auth list
  1. Bestätigen Sie Ihr Projekt:
gcloud config get project
  1. Legen Sie sie bei Bedarf fest:
export PROJECT_ID=<YOUR_PROJECT_ID>
gcloud config set project $PROJECT_ID

APIs aktivieren

Führen Sie den folgenden Befehl aus, um die erforderliche BigQuery API zu aktivieren:

gcloud services enable bigquery.googleapis.com

3. Daten laden

In diesem Schritt erstellen Sie ein BigQuery-Dataset und laden die Beispieldaten aus Cloud Storage.

Die Beispieldaten bestehen aus mehreren CSV-Dateien, die eine simulierte Einzelhandelsumgebung darstellen:

  • customers.csv: Informationen zum Kundenkonto.
  • emails.csv: E-Mail-Adressen.
  • phones.csv: Telefonnummern.
  • addresses.csv: Physische Adressen.
  • customer_emails.csv, customer_phones.csv, customer_addresses.csv: Tabellen verknüpfen.
  • orders.csv: Bestellverlauf, einschließlich Betrugs-Flags.

Dataset erstellen

Erstellen Sie ein Dataset mit dem Namen fraud_demo, um die Tabellen zu speichern.

  1. In diesem Codelab führen wir SQL-Befehle aus. Sie können diese Befehle in BigQuery Studio > SQL-Editor ausführen oder den Befehl bq query in Cloud Shell verwenden. Neue SQL-AbfrageWir gehen davon aus, dass Sie den BigQuery SQL-Editor verwenden, um mehrzeilige Erstellungsanweisungen besser zu verarbeiten.
CREATE SCHEMA IF NOT EXISTS `fraud_demo` OPTIONS(location="US");

Tabellen laden

Führen Sie die folgenden SQL-Anweisungen aus, um Daten aus Cloud Storage in Ihr Dataset zu laden.

LOAD DATA OVERWRITE `fraud_demo.customers`
FROM FILES (
  format = 'CSV',
  uris = ['gs://sample-data-and-media/fraud-demo-data/customers.csv'],
  skip_leading_rows = 1
);

LOAD DATA OVERWRITE `fraud_demo.emails`
FROM FILES (
  format = 'CSV',
  uris = ['gs://sample-data-and-media/fraud-demo-data/emails.csv'],
  skip_leading_rows = 1
);

LOAD DATA OVERWRITE `fraud_demo.phones`
FROM FILES (
  format = 'CSV',
  uris = ['gs://sample-data-and-media/fraud-demo-data/phones.csv'],
  skip_leading_rows = 1
);

LOAD DATA OVERWRITE `fraud_demo.addresses`
FROM FILES (
  format = 'CSV',
  uris = ['gs://sample-data-and-media/fraud-demo-data/addresses.csv'],
  skip_leading_rows = 1
);

LOAD DATA OVERWRITE `fraud_demo.customer_emails`
FROM FILES (
  format = 'CSV',
  uris = ['gs://sample-data-and-media/fraud-demo-data/customer_emails.csv'],
  skip_leading_rows = 1
);

LOAD DATA OVERWRITE `fraud_demo.customer_phones`
FROM FILES (
  format = 'CSV',
  uris = ['gs://sample-data-and-media/fraud-demo-data/customer_phones.csv'],
  skip_leading_rows = 1
);

LOAD DATA OVERWRITE `fraud_demo.customer_addresses`
FROM FILES (
  format = 'CSV',
  uris = ['gs://sample-data-and-media/fraud-demo-data/customer_addresses.csv'],
  skip_leading_rows = 1
);

LOAD DATA OVERWRITE `fraud_demo.orders`
FROM FILES (
  format = 'CSV',
  uris = ['gs://sample-data-and-media/fraud-demo-data/orders.csv'],
  skip_leading_rows = 1
);

4. Property Graph erstellen

Nachdem die Daten geladen wurden, können Sie den Property Graph definieren. Ein Eigenschaftsgraph besteht aus Knoten (Entitäten) und Kanten (Beziehungen).

In diesem Lab sind die Knoten:

  • Kunde: Der Kontoinhaber.
  • Telefon: Steht für eine Telefonnummer.
  • E-Mail-Adresse: Steht für eine E-Mail-Adresse.
  • Adresse: Stellt eine physische Adresse dar.

Die Kanten sind:

  • OwnsPhone: Verbindet einen Kunden mit einem Smartphone.
  • OwnsEmail: Verknüpft einen Kunden mit einer E-Mail-Adresse.
  • LinkedToAddress: Verknüpft einen Kunden mit einer Adresse.

Diagramm erstellen

Führen Sie die folgende DDL-Anweisung aus, um den Graphen mit dem Namen FraudDemo in Ihrem Dataset fraud_demo zu erstellen.

CREATE OR REPLACE PROPERTY GRAPH fraud_demo.FraudDemo
  NODE TABLES(
    fraud_demo.customers
      KEY(account_id)
      LABEL Customer PROPERTIES(
        account_id,
        name),

    fraud_demo.emails
      KEY(email)
      LABEL Email PROPERTIES(
        email,
        email_type),

    fraud_demo.phones
      KEY(phone_number)
      LABEL Phone PROPERTIES(
        phone_number,
        phone_type),

    fraud_demo.addresses
      KEY(address)
      LABEL Address PROPERTIES(
        address,
        address_type)
  )
  EDGE TABLES(
    fraud_demo.customer_emails
      KEY(account_id, email)
      SOURCE KEY(account_id) REFERENCES customers(account_id)
      DESTINATION KEY(email) REFERENCES emails(email)
      LABEL OwnsEmail PROPERTIES(
        account_id,
        email,
        last_updated_ts),

    fraud_demo.customer_phones
      KEY(account_id, phone_number)
      SOURCE KEY(account_id) REFERENCES customers(account_id)
      DESTINATION KEY(phone_number) REFERENCES phones(phone_number)
      LABEL OwnsPhone PROPERTIES(
        account_id,
        phone_number,
        last_updated_ts),

    fraud_demo.customer_addresses
      KEY(account_id, address)
      SOURCE KEY(account_id) REFERENCES customers(account_id)
      DESTINATION KEY(address) REFERENCES addresses(address)
      LABEL LinkedToAddress PROPERTIES(
        account_id,
        address,
        last_updated_ts)
  );

5. Netzwerke analysieren (2 Hops)

Öffnen Sie in BigQuery Studio ein neues Notebook.

Neues Notebook erstellen

Für die Visualisierung und die Empfehlungen in diesem Codelab verwenden wir ein Google Colab-Notebook in BigQuery Studio. So können wir die Diagrammergebnisse leicht visualisieren.

Fügen Sie Folgendes in eine Codezelle ein:

!pip install bigquery-magics==0.12.1

BigQuery Graph Notebook wird als IPython Magics implementiert. Wenn Sie den Magic-Befehl %%bigquery mit der Funktion TO_JSON hinzufügen, können Sie die Ergebnisse wie in den folgenden Abschnitten beschrieben visualisieren. In diesem Schritt führen Sie eine Graphabfrage aus, um einfache Verbindungen zwischen Konten zu finden. Dies ist eine „2-Hop“-Abfrage, da sie zwei Hops von einem Startknoten entfernt ist, um zugehörige Knoten zu finden (z.B. Kunde -> E‑Mail -> Kunde).

Wir beginnen mit der Untersuchung des Kontos von Nicole Wade. Wir möchten alle Konten finden, die über zwei Hops mit ihr in Verbindung stehen.

2-Hop-Abfrage ausführen

Führen Sie die folgende Abfrage in Ihrem Notebook aus.

%%bigquery --graph
GRAPH fraud_demo.FraudDemo
MATCH 
 p=(a:Customer) 
  ( -[e:OwnsEmail|OwnsPhone|LinkedToAddress WHERE e.last_updated_ts < '2025-07-30']- (n) ){2}
WHERE a.account_id IN ("d2f1f992-d116-41b3-955b-6c76a3352657")
  -- Verify the final node in the hop array is a Customer
  AND 'Customer' IN UNNEST(LABELS(n[OFFSET(1)]))

RETURN TO_JSON(p) AS paths

Was bedeuten die Ergebnisse?

Diese Abfrage bewirkt Folgendes:

  1. Beginnt beim Knoten Customer mit der account_id „d2f1f992-d116-41b3-955b-6c76a3352657“ (Nicole Wade).
  2. Folgt einer der Kanten OwnsEmail, OwnsPhone oder LinkedToAddress zu einem Verbindungsknoten (Phone, Email oder Address).
  3. Folgt Kanten von diesem Verbindungsknoten zurück zu anderen Customer-Knoten.
  4. Filtert Kanten anhand eines Zeitstempels (last_updated_ts), um den Status des Netzwerks zu einem bestimmten Zeitpunkt anzuzeigen.

Sie sollten sehen, dass Zachary Cordova und Brenda Brown über dieselbe Adresse mit Nicole verbunden sind.

6. Netzwerke analysieren (4 Hops)

In diesem Schritt erweitern Sie die Abfrage, um komplexere Beziehungen zu finden. Wir suchen nach 4-Hop-Verbindungen. So können wir Konten finden, die über mehrere Zwischenentitäten verbunden sind (z.B. Kunde A -> E-Mail -> Kunde B -> Telefon -> Kunde C).

Wir werden auch beobachten, wie sich dieses Netzwerk im Laufe der Zeit verändert.

Der Zustand „Vorher“

Sehen wir uns zuerst das Netzwerk am 30. Juli 2025 an.

Führen Sie die folgende Abfrage aus:

%%bigquery --graph
GRAPH fraud_demo.FraudDemo
MATCH p= ANY SHORTEST (a:Customer) 
  ( -[e:OwnsEmail|OwnsPhone|LinkedToAddress WHERE e.last_updated_ts < '2025-07-30']- (n) ){3, 5}(reachable_a:Customer)
WHERE a.account_id IN ("d2f1f992-d116-41b3-955b-6c76a3352657")
  -- Ensure the final node in the dynamic chain is actually a Customer
  AND 'Customer' IN UNNEST(LABELS(n[OFFSET(ARRAY_LENGTH(n) - 1)]))
RETURN 
  TO_JSON(p) AS paths,                   -- Array of all traversed edges
  ARRAY_LENGTH(e) AS hop_count

Der Zustand „Danach“

Sehen wir uns nun an, wie das Netzwerk zwei Wochen später aussieht. Wir führen dieselbe Abfrage aus, aber ohne die Datumseinschränkungen.

Führen Sie die folgende Abfrage aus:

%%bigquery --graph
GRAPH fraud_demo.FraudDemo
MATCH p= ANY SHORTEST (a:Customer) 
  ( -[e:OwnsEmail|OwnsPhone|LinkedToAddress]- (n) ){3, 5}(reachable_a:Customer)
WHERE a.account_id IN ("d2f1f992-d116-41b3-955b-6c76a3352657")
  -- Ensure the final node in the dynamic chain is actually a Customer
  AND 'Customer' IN UNNEST(LABELS(n[OFFSET(ARRAY_LENGTH(n) - 1)]))

RETURN 
  TO_JSON(p) AS paths,                   -- Array of all traversed edges
  ARRAY_LENGTH(e) AS hop_count

Was bedeuten die Ergebnisse?

Wenn Sie die Datumsfilter entfernen, wird die Abfrage für das gesamte Dataset ausgeführt. Sie werden feststellen, dass das Netzwerk erheblich gewachsen ist. Nicole Wade ist jetzt Teil einer viel größeren, stark vernetzten Gruppe. Diese schnelle Erweiterung eines verbundenen Netzwerks ist ein starker Indikator für potenziell betrügerische Aktivitäten, z. B. einen Betrugsring, der im Laufe der Zeit Ressourcen teilt.

7. Betrugsbericht erstellen

In diesem Schritt kombinieren Sie die Graphanalyse mit herkömmlichen Geschäftsdaten (Bestellungen), um einen umfassenden Betrugsbericht zu erstellen. Sie identifizieren gefährdete Konten und potenziell betrügerische Bestellungen.

Diese Abfrage ist komplexer. Dabei wird GRAPH_TABLE verwendet, um die Graphabfrage in Standard-SQL auszuführen, und die Änderung der Netzwerkgröße (diff) zwischen dem „Vorher“- und dem „Nachher“-Zustand berechnet, den wir im vorherigen Schritt beobachtet haben.

Abfrage für den Betrugsbericht ausführen

Führen Sie die folgende Abfrage in Ihrem Notebook aus.

%%bigquery --graph
WITH num_orders AS (
  SELECT account_id, COUNT(1) AS num_order
  FROM fraud_demo.orders
  WHERE order_time > '2025-07-30'
  GROUP BY account_id
),

orders AS (
  SELECT account_id, order_id, fraud, order_total
  FROM fraud_demo.orders
  WHERE order_time > '2025-07-30'
),

-- Use Quantified Path Patterns to find connections up to 4 hops away
latest_connect AS (
  SELECT 
    account_id, 
    ARRAY_LENGTH(ARRAY_AGG(DISTINCT connected_id)) AS size
  FROM GRAPH_TABLE(
    fraud_demo.FraudDemo
    MATCH (a:Customer)-[:OwnsEmail|OwnsPhone|LinkedToAddress]-{4}(connected:Customer)
    RETURN a.account_id AS account_id, connected.account_id AS connected_id
  )
  GROUP BY account_id
),

prev_connect AS (
  SELECT 
    account_id, 
    ARRAY_LENGTH(ARRAY_AGG(DISTINCT connected_id)) AS size
  FROM GRAPH_TABLE(
    fraud_demo.FraudDemo
    -- Apply the timestamp filter to EVERY edge in the 4-hop chain
    MATCH (a:Customer)
          (-[e:OwnsEmail|OwnsPhone|LinkedToAddress WHERE e.last_updated_ts < '2025-07-30']-(n)){4}
    WHERE 'Customer' IN UNNEST(LABELS(n[OFFSET(3)]))
    RETURN a.account_id AS account_id, n[OFFSET(3)].account_id AS connected_id
  )
  GROUP BY account_id
),

edge_changes AS (
  SELECT account_id, MAX(last_updated_ts) AS max_last_updated_ts
  FROM fraud_demo.customer_addresses
  GROUP BY account_id
)

SELECT
    la.account_id,
    o.order_id,
    la.size AS latest_size,
    COALESCE(pa.size, 0) AS previous_size,
    la.size - COALESCE(pa.size, 0) AS diff,
    nos.num_order,
    o.fraud AS reported_as_fraud,
    o.order_total,

    CASE
      WHEN (la.size - COALESCE(pa.size, 0)) > 10 AND nos.num_order IS NULL THEN "CUSTOMER AT RISK"
      WHEN (la.size - COALESCE(pa.size, 0)) > 10 AND nos.num_order IS NOT NULL AND o.fraud THEN "CONFIRMED FRAUD ORDER"
      WHEN (la.size - COALESCE(pa.size, 0)) > 10 AND nos.num_order IS NOT NULL AND NOT o.fraud THEN "POTENTIAL FRAUD ORDER"
      ELSE ""
    END AS notes
FROM latest_connect la
LEFT JOIN prev_connect pa ON la.account_id = pa.account_id
LEFT JOIN num_orders nos ON la.account_id = nos.account_id
LEFT JOIN orders o ON la.account_id = o.account_id
INNER JOIN edge_changes ec ON la.account_id = ec.account_id
WHERE nos.num_order > 1 OR (la.size - COALESCE(pa.size, 0)) > 10
ORDER BY diff DESC

Was bedeuten die Ergebnisse?

Dieser Bericht enthält Folgendes:

  • account_id: Die ID des analysierten Kontos.
  • order_id: Eine aktuelle Bestell-ID.
  • latest_size: Die aktuelle Größe des verbundenen Netzwerks.
  • previous_size: Die Größe des Netzwerks vor zwei Wochen.
  • diff: Das Wachstum der Netzwerkgröße.
  • num_order: Die Anzahl der letzten Bestellungen.
  • reported_as_fraud: Gibt an, ob die Bestellung als Betrug gekennzeichnet wurde.
  • order_total: Der Gesamtbetrag der Bestellung.
  • notes: Ein berechneter Risikostatus, der auf dem Netzwerkwachstum und dem Bestellverlauf basiert.

Sie sehen Konten mit hohen diff-Werten und hohen Bestellsummen, die sich für weitere Untersuchungen anbieten. Die Hinweise „CUSTOMER AT RISK“ (Kunde gefährdet) und „POTENTIAL FRAUD ORDER“ (Potenziell betrügerische Bestellung) helfen bei der Priorisierung dieser Konten.

8. Erkennung in großem Umfang

In diesem letzten Analyseschritt visualisieren Sie das Netzwerk in einem größeren Maßstab. Anstatt mit einem einzelnen Konto zu beginnen, fragen Sie nach Verbindungen zwischen einer Reihe verdächtiger Konten.

So können Sie feststellen, ob mehrere unabhängige Untersuchungen tatsächlich Teil desselben größeren Betrugsrings sind.

Skalierte Abfrage ausführen

Führen Sie die folgende Abfrage in Ihrem Notebook aus.

%%bigquery --graph
GRAPH fraud_demo.FraudDemo
MATCH
p= ANY SHORTEST (a:Customer) 
  ( -[e:OwnsEmail|OwnsPhone|LinkedToAddress]- (n) ){3, 5}
(reachable_a:Customer)
-- these IDs are from the previous results
WHERE a.account_id in (   "845f2b14-cd10-4750-9f28-fe542c4a731b"
  , "3ff59684-fbf9-40d7-8c41-285ade5002e6"
  , "8887c17b-e6fb-4b3b-8c62-cb721aafd028"
  , "03e777e5-6fb4-445d-b48c-cf42b7620874"
  , "81629832-eb1d-4a0e-86da-81a198604898"
  , "845f2b14-cd10-4750-9f28-fe542c4a731b",
   "89e9a8fe-ffc4-44eb-8693-a711a3534849"
 )
 LIMIT 400
RETURN TO_JSON(p) as paths

Was bedeuten die Ergebnisse?

Diese Abfrage gibt ein komplexes Diagramm zurück, das zeigt, wie sich die angegebenen verdächtigen Konten überschneiden und Ressourcen gemeinsam nutzen. Sie sehen sich jetzt die Betrugserkennung im großen Maßstab an und identifizieren Aktivitätscluster, die eine koordinierte Reaktion erfordern könnten.

9. Bereinigen

Damit Ihrem Google Cloud-Konto die in diesem Codelab verwendeten Ressourcen nicht in Rechnung gestellt werden, sollten Sie das Dataset und den Property-Graphen löschen.

Führen Sie die folgenden SQL-Anweisungen aus, um Ihre Umgebung zu bereinigen.

DROP PROPERTY GRAPH IF EXISTS fraud_demo.FraudDemo;
DROP SCHEMA IF EXISTS fraud_demo CASCADE;

10. Glückwunsch

Glückwunsch! Sie haben mit BigQuery Graph eine Lösung zur Betrugserkennung erstellt.

Sie haben Folgendes gelernt:

  • Daten aus Cloud Storage in BigQuery laden
  • Eigenschaftsgraphen mit DDL definieren
  • Fragen Sie den Graphen mit GQL ab, um einfache und komplexe Beziehungen zu finden.
  • Kombinieren Sie Graphanalysen mit Geschäftsdaten, um Risiken zu identifizieren.
  • Netzwerke in großem Umfang visualisieren

Weitere Ressourcen