Betrugserkennung mit BigQuery Graph

1. Einführung

Marketing-Überschrift – Betrug bei FinTech-Unternehmen

Bei betrügerischen Aktivitäten sind oft verborgene Netzwerke verbundener Einheiten beteiligt, z. B. mehrere Konten, die dieselbe E‑Mail-Adresse, Telefonnummer oder Postanschrift verwenden. Bei herkömmlichen relationalen Datenbanken kann es schwierig sein, diese komplexen Beziehungen mit mehreren Schritten effizient abzufragen.

Mit BigQuery Graph können Sie diese Netzwerke mithilfe von Graphdatenbanken im großen Maßstab analysieren. Sie können einen Attributgraphen für Ihre vorhandenen BigQuery-Tabellen definieren und mit der Graph Query Language (GQL) Muster in Ihren Daten finden.

Eine häufige Anwendung von Graph-Netzwerken zur Betrugserkennung ist das Stoppen von Bestellungen mit einer Lieferadresse, die mit einem Betrugsnetzwerk verknüpft ist, oder das Stoppen von Zahlungen, die zu .

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

Lerninhalte

BigQuery-Dataset erstellen und Daten laden
So definieren Sie einen Attributgraphen mit DDL.
So fragen Sie den Graphen mit GQL ab.
So können Sie mit Grafikanalysen Betrug erkennen.

Voraussetzungen

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

Kosten

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

2. Hinweis

Google Cloud-Projekt auswählen oder erstellen

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.
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.

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

Cloud Shell starten

Klicken Sie oben in der Google Cloud Console auf Cloud Shell aktivieren.
Authentifizierung überprüfen:

gcloud auth list

Bestätigen Sie Ihr Projekt:

gcloud config get project

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 Betrugsmarkierungen.

Dataset erstellen

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

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. Wir gehen davon aus, dass Sie den BigQuery SQL Editor verwenden, um mehrzeilige CREATE-Anweisungen 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 Eigenschaftsgraphen definieren. Ein Attributgraph besteht aus Knoten (Entitäten) und Kanten (Beziehungen).

In diesem Lab sind die Knoten:

Kunde: Stellt den Kontoinhaber dar.
Phone: Stellt eine Telefonnummer dar.
E-Mail: Stellt eine E-Mail-Adresse dar.
Adresse: Stellt eine physische Adresse dar.

Die Kanten sind:

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

Graph 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 Hop)

Öffnen Sie Neues Notebook in BigQuery Studio.

Neues Notebook erstellen

Für die Visualisierungs- und Empfehlungsabschnitte dieses Codelabs verwenden wir ein Google Colab-Notebook in BigQuery Studio. So können wir die Grafikergebnisse ganz einfach visualisieren.

BigQuery Graph Notebook wird als IPython-Magic-Befehl implementiert. Wenn Sie den Magic-Befehl %%bigquery mit der Funktion TO_JSON hinzufügen, können Sie die Ergebnisse wie in den folgenden Abschnitten dargestellt visualisieren. In diesem Schritt führen Sie eine Diagrammabfrage aus, um einfache Verbindungen zwischen Konten zu finden. Dies ist eine „2-Hop“-Abfrage, da sie zwei Schritte vom 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 Schritte 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

Ergebnisse nachvollziehen

Diese Abfrage bewirkt Folgendes:

Beginnt am Knoten Customer mit account_id „d2f1f992-d116-41b3-955b-6c76a3352657“ (Nicole Wade).
Folgt einer der Kanten OwnsEmail, OwnsPhone oder LinkedToAddress zu einem Verbindungs-Knoten (Phone, Email oder Address).
Folgt Kanten von diesem Verbindungsknoten zurück zu anderen Customer-Knoten.
Kanten werden anhand eines Zeitstempels (last_updated_ts) gefiltert, um den Zustand des Netzwerks zu einem bestimmten Zeitpunkt zu sehen.

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 miteinander verbunden sind (z.B. Kunde A –> E-Mail-Adresse –> Kunde B –> Telefonnummer –> Kunde C).

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

Der Status „Vorher“

Sehen wir uns zuerst das Netzwerk an, wie es am 30. Juli 2025 bestand.

Führen Sie die folgende Abfrage aus:

%%bigquery --graph
%%bigquery --graph

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)]))
GRAPH fraud_demo.FraudDemo
RETURN 
  TO_JSON(p) AS paths,                   -- Array of all traversed edges
  ARRAY_LENGTH(e) AS hop_count

Der „Nach“-Status

Sehen wir uns nun an, wie das Netzwerk zwei Wochen später aussieht. Wir führen dieselbe Abfrage noch einmal aus, aber ohne die Datumsbeschrä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

Ergebnisse nachvollziehen

Wenn Sie die Datumsfilter entfernen, wird die gesamte Datenmenge abgefragt. Sie werden feststellen, dass das Netzwerk deutlich gewachsen ist. Nicole Wade ist jetzt Teil einer viel größeren, stark vernetzten Gruppe. Diese schnelle Ausweitung eines verbundenen Netzwerks ist ein starker Hinweis auf potenziell betrügerische Aktivitäten, z. B. wenn ein Betrugsring Ressourcen im Laufe der Zeit gemeinsam nutzt.

7. Betrugsbericht erstellen

In diesem Schritt kombinieren Sie die Grafikanalyse mit herkömmlichen Geschäftsdaten (Bestellungen), um einen umfassenden Betrugsbericht zu erstellen. Sie können gefährdete Konten und potenzielle betrügerische Bestellungen erkennen.

Diese Abfrage ist komplexer. Dazu wird GRAPH_TABLE verwendet, um die Diagrammabfrage in Standard-SQL auszuführen und die Änderung der Netzwerkgröße (diff) zwischen den Zuständen „Vorher“ und „Nachher“ zu berechnen, die wir im vorherigen Schritt beobachtet haben.

Abfrage für 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

Ergebnisse nachvollziehen

Dieser Bericht enthält:

account_id: Die ID des Kontos, das analysiert wird.
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 betrügerisch gekennzeichnet wurde.
order_total: Der Gesamtbetrag der Bestellung.
notes: Ein berechneter Risikostatus basierend auf dem Netzwerkwachstum und dem Bestellverlauf.

Sie sehen Konten mit hohen diff-Werten und hohen Gesamtsummen für Bestellungen, die sich für eine weitere Untersuchung eignen. Anhand der Hinweise „KUNDE MIT RISIKO“ und „MÖGLICHER BETRUGSVERSUCH“ können Sie diese Konten priorisieren.

8. Erkennung in großem Umfang

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

So können Sie sehen, 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

Ergebnisse nachvollziehen

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

9. Bereinigen

Löschen Sie den Datensatz und den Property-Graphen, damit Ihrem Google Cloud-Konto die in diesem Codelab verwendeten Ressourcen nicht in Rechnung gestellt werden.

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 erfolgreich eine Lösung zur Betrugserkennung erstellt.

Sie haben Folgendes gelernt:

Daten aus Cloud Storage in BigQuery laden
Definieren Sie einen Attributgraphen mit DDL.
Sie können den Graph mit GQL abfragen, um einfache und komplexe Beziehungen zu finden.
Kombinieren Sie Graph-Analysen mit Geschäftsdaten, um Risiken zu erkennen.
Netzwerke in großem Umfang visualisieren.

Weitere Ressourcen

BigQuery Graph-Dokumentation

Betrugserkennung mit BigQuery Graph Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

1. Einführung

Lerninhalte

Voraussetzungen

Kosten

2. Hinweis

Google Cloud-Projekt auswählen oder erstellen

Umgebung auswählen

Cloud Shell starten

APIs aktivieren

3. Daten laden

Dataset erstellen

Tabellen laden

4. Property Graph erstellen

Graph erstellen

5. Netzwerke analysieren (2 Hop)

2-Hop-Abfrage ausführen

Ergebnisse nachvollziehen

6. Netzwerke analysieren (4 Hops)

Der Status „Vorher“

Der „Nach“-Status

Ergebnisse nachvollziehen

7. Betrugsbericht erstellen

Abfrage für Betrugsbericht ausführen

Ergebnisse nachvollziehen

8. Erkennung in großem Umfang

Skalierte Abfrage ausführen

Ergebnisse nachvollziehen

9. Bereinigen

10. Glückwunsch

Weitere Ressourcen

Betrugserkennung mit BigQuery Graph