Wykrywanie oszustw za pomocą BigQuery Graph

1. Wprowadzenie

Marketing Header - Fraud in Fintech

Nieuczciwe działania często obejmują ukryte sieci powiązanych podmiotów, np. wiele kont korzystających z tego samego adresu e-mail, numeru telefonu lub adresu pocztowego. Tradycyjne relacyjne bazy danych mogą mieć trudności z efektywnym wykonywaniem zapytań dotyczących tych złożonych, wieloetapowych relacji.

BigQuery Graph umożliwia analizowanie tych sieci na dużą skalę za pomocą baz danych grafów. Możesz zdefiniować graf właściwości na podstawie istniejących tabel BigQuery i użyć języka Graph Query Language (GQL) do znajdowania wzorców w danych.

Typowym zastosowaniem sieci grafowych do wykrywania oszustw jest zatrzymywanie zamówień, których adres dostawy jest powiązany z siecią oszustw, lub zatrzymywanie płatności należących do oszustów .

W tym ćwiczeniu utworzysz rozwiązanie do wykrywania oszustw przy użyciu BigQuery Graph. Wczytasz dane z Cloud Storage, utworzysz graf właściwości i użyjesz zapytań grafowych do identyfikacji podejrzanych połączeń.

Czego się nauczysz

  • jak utworzyć zbiór danych BigQuery i wczytać dane,
  • Jak zdefiniować graf właściwości za pomocą DDL.
  • jak wysyłać zapytania do grafu za pomocą GQL.
  • Jak używać analizy grafów do wykrywania oszustw.

Czego potrzebujesz

  • projekt Google Cloud z włączonymi płatnościami,
  • środowisko notatników BigQuery (BigQuery Studio lub Colab Enterprise);

Koszt

W tym module używane są zasoby Google Cloud, które są płatne. Szacowany koszt to mniej niż 5 USD, przy założeniu, że po zakończeniu usuniesz zasoby.

2. Zanim zaczniesz

Wybieranie lub tworzenie projektu Google Cloud

  1. W konsoli Google Cloud na stronie selektora projektów wybierz lub utwórz projekt w chmurze Google Cloud.
  2. Sprawdź, czy w projekcie Google Cloud włączone są płatności. Dowiedz się, jak sprawdzić, czy płatności są włączone.

Wybieranie środowiska

Do wykonania tego modułu potrzebne jest środowisko notatnika. Możesz używać BigQuery Studio lub Colab Enterprise.

  1. Otwórz stronę BigQuery w konsoli Google Cloud.
  2. Do uruchamiania zapytań dotyczących wykresów użyjesz notatnika Pythona.

Uruchamianie Cloud Shell

  1. Kliknij Aktywuj Cloud Shell na górze konsoli Google Cloud.
  2. Weryfikacja uwierzytelniania:
gcloud auth list
  1. Potwierdź projekt:
gcloud config get project
  1. W razie potrzeby ustaw:
export PROJECT_ID=<YOUR_PROJECT_ID>
gcloud config set project $PROJECT_ID

Włącz interfejsy API

Uruchom to polecenie, aby włączyć wymagany interfejs BigQuery API:

gcloud services enable bigquery.googleapis.com

3. Wczytaj dane

W tym kroku utworzysz zbiór danych BigQuery i wczytasz dane próbkowane z Cloud Storage.

Przykładowe dane składają się z kilku plików CSV reprezentujących symulowane środowisko sprzedaży detalicznej:

  • customers.csv: informacje o koncie klienta.
  • emails.csv: adresy e-mail,
  • phones.csv: numery telefonów,
  • addresses.csv: adresy pocztowe.
  • customer_emails.csv, customer_phones.csv, customer_addresses.csv: łączenie tabel.
  • orders.csv: historia zamówień, w tym oznaczenia oszustw.

Tworzenie zbioru danych

Utwórz zbiór danych o nazwie fraud_demo, w którym będą przechowywane tabele.

  1. W tym ćwiczeniu z programowania będziemy wykonywać polecenia SQL. Możesz uruchomić te polecenia w BigQuery Studio > Edytor SQL lub użyć polecenia bq query w Cloud Shell. Nowe zapytanie SQLZakładamy, że używasz edytora SQL BigQuery, aby ułatwić sobie pracę z wielowierszowymi instrukcjami tworzenia.
CREATE SCHEMA IF NOT EXISTS `fraud_demo` OPTIONS(location="US");

Wczytywanie tabel

Uruchom te instrukcje SQL, aby wczytać dane z Cloud Storage do zbioru danych.

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. Tworzenie grafu właściwości

Po wczytaniu danych możesz zdefiniować graf właściwości. Wykres właściwości składa się z węzłów (encji) i krawędzi (relacji).

W tym module węzły to:

  • Klient: reprezentuje właściciela konta.
  • Telefon: reprezentuje numer telefonu.
  • E-mail: reprezentuje adres e-mail.
  • Adres: reprezentuje adres pocztowy.

Krawędzie to:

  • OwnsPhone: łączy klienta z telefonem.
  • OwnsEmail: łączy klienta z adresem e-mail.
  • LinkedToAddress: łączy klienta z adresem.

Tworzenie grafu

Uruchom tę instrukcję DDL, aby utworzyć graf o nazwie FraudDemo w zbiorze danych fraud_demo.

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. Analizowanie sieci (2 skoki)

Otwórz Nowy notatnik w BigQuery Studio.

Utwórz nowy notatnik

W częściach tego ćwiczenia dotyczących wizualizacji i rekomendacji użyjemy notatnika Google Colab w BigQuery Studio. Dzięki temu możemy łatwo wizualizować wyniki wykresu.

Wklej w komórce kodu ten kod:

!pip install bigquery-magics==0.12.1

Notatnik BigQuery Graph jest implementowany jako polecenia magiczne IPython. Dodając polecenie magiczne %%bigquery z funkcją TO_JSON, możesz wizualizować wyniki, jak pokazano w kolejnych sekcjach. W tym kroku uruchomisz zapytanie dotyczące grafu, aby znaleźć proste połączenia między kontami. Jest to zapytanie „2-hop”, ponieważ przechodzi przez 2 węzły od węzła początkowego, aby znaleźć powiązane węzły (np. Klient -> E-mail -> Klient).

Zaczniemy od sprawdzenia konta należącego do Nicole Wade. Chcemy znaleźć wszystkie konta powiązane z nią przez 2 przeskoki.

Uruchamianie zapytania 2-skokowego

Uruchom w notatniku poniższe zapytanie.

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

Interpretowanie wyników

To zapytanie:

  1. Zaczyna się w węźle Customer z account_id „d2f1f992-d116-41b3-955b-6c76a3352657” (Nicole Wade).
  2. podąża za dowolną krawędzią OwnsEmail, OwnsPhone lub LinkedToAddress do węzła łączącego (Phone, Email lub Address).
  3. podąża krawędziami od tego węzła łączącego do innych węzłów Customer.
  4. Filtruje krawędzie na podstawie sygnatury czasowej (last_updated_ts), aby wyświetlić stan sieci w określonym czasie.

Powinno być widać, że Zachary Cordova i Brenda Brown są połączeni z Nicole przez ten sam adres.

6. Analiza sieci (4 przeskoki)

W tym kroku rozszerzysz zapytanie, aby znaleźć bardziej złożone relacje. Będziemy szukać połączeń 4-hop. Dzięki temu możemy znaleźć konta, które są połączone przez kilka podmiotów pośredniczących (np. Klient A -> adres e-mail -> Klient B -> numer telefonu -> Klient C).

Będziemy też obserwować, jak ta sieć zmienia się w czasie.

Stan „Przed”

Najpierw przyjrzyjmy się sieci w stanie z 30 lipca 2025 r.

Uruchom poniższe zapytanie:

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

Stan „po”

Zobaczmy, jak wygląda sieć 2 tygodnie później. Uruchomimy to samo zapytanie, ale bez ograniczeń dat.

Uruchom poniższe zapytanie:

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

Interpretowanie wyników

Usunięcie filtrów daty spowoduje, że zapytanie będzie dotyczyć całego zbioru danych. Zauważysz, że sieć znacznie się rozrosła. Nicole Wade należy teraz do znacznie większej, połączonej grupy. Takie szybkie rozszerzanie połączonej sieci jest silnym wskaźnikiem potencjalnie nieuczciwych działań, takich jak udostępnianie zasobów przez grupę oszustów.

7. Generowanie raportu o oszustwach

W tym kroku połączysz analizę grafów z tradycyjnymi danymi biznesowymi (zamówieniami), aby wygenerować kompleksowy raport o oszustwach. Zidentyfikujesz konta zagrożone i potencjalnie fałszywe zamówienia.

To zapytanie jest bardziej złożone. Używa GRAPH_TABLE do uruchomienia zapytania grafowego w standardowej wersji SQL i oblicza zmianę rozmiaru sieci (diff) między stanami „przed” i „po” zaobserwowanymi w poprzednim kroku.

Uruchamianie zapytania dotyczącego raportu o oszustwach

Uruchom w notatniku poniższe zapytanie.

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

Interpretowanie wyników

Ten raport zawiera:

  • account_id: identyfikator analizowanego konta.
  • order_id: identyfikator ostatniego zamówienia.
  • latest_size: rozmiar połączonej sieci obecnie.
  • previous_size: rozmiar sieci 2 tygodnie temu.
  • diff: wzrost rozmiaru sieci.
  • num_order: liczba ostatnich zamówień.
  • reported_as_fraud: czy zamówienie zostało oznaczone jako oszustwo.
  • order_total: łączna kwota zamówienia.
  • notes: obliczony stan ryzyka na podstawie rozwoju sieci i historii zamówień.

Zobaczysz konta z dużymi wartościami diff i wysokimi sumami zamówień, które są głównymi kandydatami do dalszej analizy. Notatki „KLIENT ZAGROŻONY” i „POTENCJALNE ZAMÓWIENIE OSZUSTA” pomagają ustalić priorytety tych kont.

8. Wykrywanie na dużą skalę

W tym ostatnim kroku analizy zwizualizujesz sieć w większej skali. Zamiast zaczynać od jednego konta, wyszukasz połączenia między zestawem podejrzanych kont.

Dzięki temu możesz sprawdzić, czy kilka niezależnych dochodzeń nie jest w rzeczywistości częścią tego samego, większego oszustwa.

Uruchamianie zapytania skalowanego

Uruchom w notatniku poniższe zapytanie.

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

Interpretowanie wyników

To zapytanie zwraca złożony wykres pokazujący, jak określone podejrzane konta nakładają się na siebie i udostępniają zasoby. Teraz analizujesz wykrywanie oszustw na dużą skalę, identyfikując klastry aktywności, które mogą wymagać skoordynowanej reakcji.

9. Czyszczenie

Aby uniknąć obciążenia konta Google Cloud opłatami za zasoby zużyte w tym ćwiczeniu, usuń zbiór danych i graf właściwości.

Aby wyczyścić środowisko, uruchom te instrukcje SQL.

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

10. Gratulacje

Gratulacje! Udało Ci się utworzyć rozwiązanie do wykrywania oszustw za pomocą BigQuery Graph.

Wiesz już, jak:

  • wczytać dane z Cloud Storage do BigQuery;
  • Zdefiniuj graf właściwości za pomocą DDL.
  • Tworzenie zapytań do grafu za pomocą GQL w celu znalezienia prostych i złożonych relacji.
  • Połącz analizę grafów z firmowymi bazami danych, aby identyfikować ryzyko.
  • Wizualizacja sieci na dużą skalę.

Więcej zasobów