Betrügerische Aktivitäten haben schwerwiegende Auswirkungen auf viele Branchen wie E-Commerce, soziale Medien und Finanzdienstleistungen. Betrug kann Unternehmen und Verbrauchern erhebliche Verluste zufügen. Amerikanische Verbraucher gaben an, im Jahr 5.8 mehr als 2021 Milliarden US-Dollar durch Betrug verloren zu haben, was einem Anstieg von mehr als 70 % gegenüber 2020 entspricht. Viele Techniken wurden verwendet, um Betrüger zu erkennen – regelbasierte Filter, Anomalieerkennung und Modelle für maschinelles Lernen (ML), um nur einige zu nennen.

In realen Daten beinhalten Entitäten oft umfangreiche Beziehungen zu anderen Entitäten. Eine solche Graphenstruktur kann wertvolle Informationen für die Erkennung von Anomalien liefern. In der folgenden Abbildung sind Benutzer beispielsweise über freigegebene Entitäten wie Wi-Fi-IDs, physische Standorte und Telefonnummern verbunden. Aufgrund der großen Anzahl eindeutiger Werte dieser Entitäten, wie Telefonnummern, ist es schwierig, sie in den traditionellen funktionsbasierten Modellen zu verwenden – zum Beispiel wäre eine One-Hot-Codierung aller Telefonnummern nicht realisierbar. Aber solche Beziehungen könnten helfen vorherzusagen, ob ein Benutzer ein Betrüger ist. Wenn ein Benutzer mehrere Entitäten mit einem bekannten Betrüger geteilt hat, ist der Benutzer mit größerer Wahrscheinlichkeit ein Betrüger.

In letzter Zeit ist das Graph Neural Network (GNN) zu einer beliebten Methode zur Betrugserkennung geworden. GNN-Modelle können sowohl die Graphstruktur als auch Attribute von Knoten oder Kanten wie Benutzer oder Transaktionen kombinieren, um aussagekräftige Darstellungen zu lernen, um böswillige Benutzer und Ereignisse von legitimen zu unterscheiden. Diese Fähigkeit ist entscheidend für die Erkennung von Betrug, bei dem Betrüger zusammenarbeiten, um ihre abnormalen Merkmale zu verbergen, aber einige Spuren von Beziehungen hinterlassen.

Aktuelle GNN-Lösungen setzen hauptsächlich auf Offline-Batch-Training und Inferenzmodus, die Betrüger erkennen, nachdem böswillige Ereignisse stattgefunden haben und Verluste aufgetreten sind. Das Aufspüren betrügerischer Benutzer und Aktivitäten in Echtzeit ist jedoch entscheidend, um Verluste zu vermeiden. Dies gilt insbesondere in Geschäftsfällen, in denen es nur eine Chance gibt, betrügerische Aktivitäten zu verhindern. Beispielsweise ist die Kontoregistrierung auf einigen E-Commerce-Plattformen weit offen. Betrüger können sich mit einem Konto nur einmal böswillig verhalten und dasselbe Konto nie wieder verwenden.

Es ist wichtig, Betrüger in Echtzeit vorherzusagen. Der Aufbau einer solchen Lösung ist jedoch eine Herausforderung. Da GNNs noch neu in der Branche sind, gibt es nur begrenzte Online-Ressourcen zum Konvertieren von GNN-Modellen von der Batch-Bereitstellung in die Echtzeit-Bereitstellung. Darüber hinaus ist es eine Herausforderung, eine Streaming-Datenpipeline zu konstruieren, die eingehende Ereignisse an eine GNN-Echtzeit-Serving-API weiterleiten kann. Nach bestem Wissen der Autoren sind zum jetzigen Zeitpunkt keine Referenzarchitekturen und Beispiele für GNN-basierte Echtzeit-Inferenzlösungen verfügbar.

Um Entwicklern dabei zu helfen, GNNs für die Echtzeit-Betrugserkennung anzuwenden, zeigt dieser Beitrag, wie man sie verwendet Amazon Neptun, Amazon Sage Makerund der Deep-Graph-Bibliothek (DGL), neben anderen AWS-Services, um eine End-to-End-Lösung für die Echtzeit-Betrugserkennung mithilfe von GNN-Modellen zu erstellen.

Wir konzentrieren uns auf vier Aufgaben:

• Verarbeitung eines tabellarischen Transaktionsdatensatzes in einen heterogenen Diagrammdatensatz
• Trainieren eines GNN-Modells mit SageMaker
• Bereitstellen der trainierten GNN-Modelle als SageMaker-Endpunkt
• Demonstrieren der Echtzeit-Inferenz für eingehende Transaktionen

Dieser Beitrag erweitert die bisherige Arbeit in Aufdeckung von Betrug in heterogenen Netzwerken mithilfe von Amazon SageMaker und Deep Graph Library, die sich auf die ersten beiden Aufgaben konzentriert. Weitere Informationen zu heterogenen Graphen, GNNs und halbüberwachtem Training von GNNs finden Sie in diesem Beitrag.

Unternehmen, die nach einem vollständig verwalteten AWS-KI-Service zur Betrugserkennung suchen, können ihn ebenfalls verwenden Amazon Fraud DetectorDies macht es einfach, potenziell betrügerische Online-Aktivitäten wie die Erstellung gefälschter Konten oder Online-Zahlungsbetrug zu identifizieren.

Lösungsüberblick

Diese Lösung besteht aus zwei Hauptteilen.

Der erste Teil ist eine Pipeline, die die Daten verarbeitet, GNN-Modelle trainiert und die trainierten Modelle bereitstellt. Es verwendet AWS-Kleber zur Verarbeitung der Transaktionsdaten und speichert die verarbeiteten Daten auf beiden Amazon Neptun und Amazon Simple Storage-Service (Amazon S3). Dann wird ein SageMaker-Trainingsjob ausgelöst, um ein GNN-Modell mit den in Amazon S3 gespeicherten Daten zu trainieren, um vorherzusagen, ob eine Transaktion betrügerisch ist. Das trainierte Modell wird zusammen mit anderen Assets nach Abschluss des Trainingsauftrags wieder in Amazon S3 gespeichert. Schließlich wird das gespeicherte Modell als SageMaker-Endpunkt bereitgestellt. Die Pipeline wird orchestriert von AWS Step-Funktionen, wie in der folgenden Abbildung gezeigt.

Der zweite Teil der Lösung implementiert die Erkennung betrügerischer Transaktionen in Echtzeit. Es beginnt mit einer RESTful-API, die die Diagrammdatenbank in Neptune abfragt, um das Unterdiagramm zu extrahieren, das sich auf eine eingehende Transaktion bezieht. Es verfügt auch über ein Webportal, das Geschäftsaktivitäten simulieren kann und Online-Transaktionen sowohl mit betrügerischen als auch mit legitimen Transaktionen generiert. Das Webportal bietet eine Live-Visualisierung der Betrugserkennung. Dieser Teil verwendet Amazon CloudFront, AWS verstärken, AWS AppSync, Amazon API-Gateway, Schrittfunktionen und Amazon DocumentDB um die Webanwendung schnell zu erstellen. Das folgende Diagramm veranschaulicht den Echtzeit-Inferenzprozess und das Webportal.

Die Implementierung dieser Lösung, zusammen mit einer AWS CloudFormation Vorlage, mit der die Architektur in Ihrem AWS-Konto gestartet werden kann, ist über Folgendes öffentlich verfügbar GitHub Repo.

Datenverarbeitung

In diesem Abschnitt beschreiben wir kurz, wie ein Beispieldatensatz verarbeitet und aus Rohtabellen in ein Diagramm mit zwischen verschiedenen Spalten identifizierten Beziehungen umgewandelt wird.

Diese Lösung verwendet denselben Datensatz, die IEEE-CIS-Betrugsdatensatz, wie der vorherige Beitrag Aufdeckung von Betrug in heterogenen Netzwerken mithilfe von Amazon SageMaker und Deep Graph Library. Daher ist das Grundprinzip der Datenverarbeitung dasselbe. Kurz gesagt, der Betrugsdatensatz enthält eine Transaktionstabelle und eine Identitätstabelle mit fast 500,000 anonymisierten Transaktionsaufzeichnungen zusammen mit Kontextinformationen (z. B. bei Transaktionen verwendete Geräte). Einige Transaktionen haben ein binäres Etikett, das angibt, ob eine Transaktion betrügerisch ist. Unsere Aufgabe ist es, vorherzusagen, welche nicht gekennzeichneten Transaktionen betrügerisch und welche legitim sind.

Die folgende Abbildung veranschaulicht den allgemeinen Prozess zum Konvertieren der IEEE-Tabellen in ein heterogenes Diagramm. Wir extrahieren zunächst zwei Spalten aus jeder Tabelle. Eine Spalte ist immer die Transaktions-ID-Spalte, in der wir jede eindeutige Transaktions-ID als einen Knoten festlegen. Eine weitere Spalte wird aus den kategorialen Spalten ausgewählt, z. B. den Spalten ProductCD und id_03, in denen jede eindeutige Kategorie als Knoten festgelegt wurde. Wenn eine TransactionID und eine eindeutige Kategorie in derselben Zeile erscheinen, verbinden wir sie mit einer Kante. Auf diese Weise konvertieren wir zwei Spalten in einer Tabelle in eine Bipartite. Dann kombinieren wir diese Bipartites zusammen mit den TransactionID-Knoten, wobei dieselben TransactionID-Knoten zu einem eindeutigen Knoten zusammengeführt werden. Nach diesem Schritt haben wir einen heterogenen Graphen, der aus Bipartiten aufgebaut ist.

Die restlichen Spalten, die nicht zum Erstellen des Diagramms verwendet werden, verbinden wir als Merkmal der TransactionID-Knoten. TransactionID-Werte, die die isFraud-Werte haben, werden als Bezeichnung für das Modelltraining verwendet. Basierend auf diesem heterogenen Graphen wird unsere Aufgabe zu einer Knotenklassifizierungsaufgabe der TransactionID-Knoten. Weitere Einzelheiten zum Vorbereiten der Diagrammdaten für das Training von GNNs finden Sie unter Feature-Extraktion und Aufbau des Graphen Abschnitte des vorherigen Blogbeitrags.

Der in dieser Lösung verwendete Code ist verfügbar in src/scripts/glue-etl.py. Sie können auch mit der Datenverarbeitung über das Jupyter-Notebook experimentieren src/sagemaker/01.FD_SL_Process_IEEE-CIS_Dataset.ipynb.

Anstatt die Daten wie im vorherigen Beitrag manuell zu verarbeiten, verwendet diese Lösung eine vollautomatische Pipeline, die von Step Functions und AWS Glue orchestriert wird und die parallele Verarbeitung großer Datensätze über Apache Spark unterstützt. Der Step-Functions-Workflow ist eingeschrieben AWS Cloud-Entwicklungskit (AWS-CDK). Das Folgende ist ein Code-Auszug So erstellen Sie diesen Workflow:

import { LambdaInvoke, GlueStartJobRun } from 'aws-cdk-lib/aws-stepfunctions-tasks';
    
    const parametersNormalizeTask = new LambdaInvoke(this, 'Parameters normalize', {
      lambdaFunction: parametersNormalizeFn,
      integrationPattern: IntegrationPattern.REQUEST_RESPONSE,
    });
    
    ...
    
    const dataProcessTask = new GlueStartJobRun(this, 'Data Process', {
      integrationPattern: IntegrationPattern.RUN_JOB,
      glueJobName: etlConstruct.jobName,
      timeout: Duration.hours(5),
      resultPath: '$.dataProcessOutput',
    });
    
    ...    
    
    const definition = parametersNormalizeTask
      .next(dataIngestTask)
      .next(dataCatalogCrawlerTask)
      .next(dataProcessTask)
      .next(hyperParaTask)
      .next(trainingJobTask)
      .next(runLoadGraphDataTask)
      .next(modelRepackagingTask)
      .next(createModelTask)
      .next(createEndpointConfigTask)
      .next(checkEndpointTask)
      .next(endpointChoice);

Neben der Erstellung der Diagrammdaten für das GNN-Modelltraining lädt dieser Workflow auch die Diagrammdaten in Neptune, um später eine Echtzeit-Inferenz durchzuführen. Dieser Batch-Datenladevorgang wird im folgenden Codeausschnitt demonstriert:

from neptune_python_utils.endpoints import Endpoints
from neptune_python_utils.bulkload import BulkLoad

...

bulkload = BulkLoad(
        source=targetDataPath,
        endpoints=endpoints,
        role=args.neptune_iam_role_arn,
        region=args.region,
        update_single_cardinality_properties=True,
        fail_on_error=True)
        
load_status = bulkload.load_async()
status, json = load_status.status(details=True, errors=True)
load_status.wait()

GNN-Modelltraining

Nachdem die Diagrammdaten für das Modelltraining in Amazon S3 gespeichert wurden, a SageMaker-Ausbildungsjob, das nur während der Ausführung des Trainingsauftrags berechnet wird, wird ausgelöst, um den GNN-Modelltrainingsprozess im Modus „Bring Your Own Container“ (BYOC) zu starten. Es ermöglicht Ihnen, Ihre Modelltrainingsskripte und -abhängigkeiten in ein Docker-Image zu packen, das zum Erstellen von SageMaker-Trainingsinstanzen verwendet wird. Die BYOC-Methode könnte erheblichen Aufwand beim Aufbau der Trainingsumgebung einsparen. Im src/sagemaker/02.FD_SL_Build_Training_Container_Test_Local.ipynbfinden Sie Details zum GNN-Modelltraining.

Docker-Bild

Der erste Teil der Jupyter-Notebook-Datei ist die Trainings-Docker-Image-Generierung (siehe folgendes Code-Snippet):

*!* aws ecr get-login-password --region us-east-1 | docker login --username AWS --password-stdin 763104351884.dkr.ecr.us-east-1.amazonaws.com
image_name *=* 'fraud-detection-with-gnn-on-dgl/training'
*!* docker build -t $image_name ./FD_SL_DGL/gnn_fraud_detection_dgl

Wir haben ein PyTorch-basiertes Bild für das Modelltraining verwendet. Die Deep Graph Library (DGL) und andere Abhängigkeiten werden beim Erstellen des Docker-Images installiert. Der GNN-Modellcode in der src/sagemaker/FD_SL_DGL/gnn_fraud_detection_dgl Ordner wird ebenfalls in das Bild kopiert.

Da wir die Transaktionsdaten in einem heterogenen Diagramm verarbeiten, wählen wir in dieser Lösung die Faltungsnetzwerk für relationale Graphen (RGCN)-Modell, das speziell für heterogene Graphen entwickelt wurde. Unser RGCN-Modell kann lernbare Einbettungen für die Knoten in heterogenen Graphen trainieren. Dann werden die erlernten Einbettungen als Eingaben einer vollständig verbundenen Schicht zum Vorhersagen der Knotenkennzeichnungen verwendet.

Hyperparameter

Um das GNN zu trainieren, müssen wir vor dem Trainingsprozess einige Hyperparameter definieren, wie z. B. die Dateinamen des konstruierten Graphen, die Anzahl der Schichten von GNN-Modellen, die Trainingsepochen, den Optimierer, die Optimierungsparameter und mehr. Sehen Sie sich den folgenden Code für eine Teilmenge der Konfigurationen an:

edges *=* ","*.*join(map(*lambda* x: x*.*split("/")[*-*1], [file *for* file *in* processed_files *if* "relation" *in* file]))

params *=* {'nodes' : 'features.csv',
          'edges': edges,
          'labels': 'tags.csv',
          'embedding-size': 64,
          'n-layers': 2,
          'n-epochs': 10,
          'optimizer': 'adam',
          'lr': 1e-2}

Weitere Informationen zu allen Hyperparametern und ihren Standardwerten finden Sie unter estimator_fns.py der src/sagemaker/FD_SL_DGL/gnn_fraud_detection_dgl -Ordner.

Modelltraining mit SageMaker

Nachdem das benutzerdefinierte Container-Docker-Image erstellt wurde, verwenden wir die vorverarbeiteten Daten, um unser GNN-Modell mit den von uns definierten Hyperparametern zu trainieren. Der Trainingsjob verwendet die DGL mit PyTorch als Back-End-Framework für Deep Learning, um das GNN zu erstellen und zu trainieren. SageMaker erleichtert das Trainieren von GNN-Modellen mit dem angepassten Docker-Image, das ein Eingabeargument des SageMaker-Schätzers ist. Weitere Informationen zum Trainieren von GNNs mit der DGL auf SageMaker finden Sie unter Trainiere ein Deep Graph Netzwerk.

Das SageMaker Python SDK verwendet Estimator um das Training auf SageMaker zu kapseln, das SageMaker-kompatible benutzerdefinierte Docker-Container ausführt, sodass Sie Ihre eigenen ML-Algorithmen mithilfe des SageMaker-Python-SDK ausführen können. Das folgende Code-Snippet demonstriert das Trainieren des Modells mit SageMaker (entweder in einer lokalen Umgebung oder in Cloud-Instanzen):

from sagemaker.estimator import Estimator
from time import strftime, gmtime
from sagemaker.local import LocalSession

localSageMakerSession = LocalSession(boto_session=boto3.session.Session(region_name=current_region))
estimator = Estimator(image_uri=image_name,
                      role=sagemaker_exec_role,
                      instance_count=1,
                      instance_type='local',
                      hyperparameters=params,
                      output_path=output_path,
                      sagemaker_session=localSageMakerSession)

training_job_name = "{}-{}".format('GNN-FD-SL-DGL-Train', strftime("%Y-%m-%d-%H-%M-%S", gmtime()))
print(training_job_name)

estimator.fit({'train': processed_data}, job_name=training_job_name)

Nach dem Training wird die Leistung des GNN-Modells auf dem Testset wie die folgenden Ausgaben angezeigt. Das RGCN-Modell kann normalerweise etwa 0.87 AUC und eine Genauigkeit von mehr als 95 % erreichen. Einen Vergleich des RGCN-Modells mit anderen ML-Modellen finden Sie unter Die Ergebnisse Abschnitt des vorherigen Blogbeitrags für weitere Details.

Epoch 00099 | Time(s) 7.9413 | Loss 0.1023 | f1 0.3745
Metrics
Confusion Matrix:
                        labels positive labels negative
    predicted positive  4343            576
    predicted negative  13494           454019

    f1: 0.3817, precision: 0.8829, recall: 0.2435, acc: 0.9702, roc: 0.8704, pr: 0.4782, ap: 0.4782

Finished Model training

Nach Abschluss des Modelltrainings packt SageMaker das trainierte Modell zusammen mit anderen Assets, einschließlich der trainierten Knoteneinbettungen, in eine ZIP-Datei und lädt sie dann an einen bestimmten S3-Speicherort hoch. Als Nächstes besprechen wir den Einsatz des trainierten Modells für die Betrugserkennung in Echtzeit.

Bereitstellung des GNN-Modells

SageMaker vereinfacht die Bereitstellung trainierter ML-Modelle. In dieser Phase verwenden wir die SageMaker-PyTorchModel-Klasse, um das trainierte Modell bereitzustellen, da unser DGL-Modell von PyTorch als Back-End-Framework abhängt. Den Bereitstellungscode finden Sie in der src/sagemaker/03.FD_SL_Endpoint_Deployment.ipynb Datei.

Neben der trainierten Modelldatei und den Assets benötigt SageMaker eine Einstiegspunktdatei für die Bereitstellung eines benutzerdefinierten Modells. Die Einstiegspunktdatei wird ausgeführt und im Speicher einer Inferenzendpunktinstanz gespeichert, um auf die Inferenzanforderung zu antworten. In unserem Fall ist die Einstiegspunktdatei die fd_sl_deployment_entry_point.py Datei in das src/sagemaker/FD_SL_DGL/code Ordner, der vier Hauptfunktionen ausführt:

• Anfragen empfangen und Inhalte von Anfragen parsen, um die vorherzusagenden Knoten und ihre zugehörigen Daten zu erhalten
• Konvertieren Sie die Daten in ein heterogenes DGL-Diagramm als Eingabe für das RGCN-Modell
• Führen Sie die Echtzeit-Inferenz über das trainierte RGCN-Modell durch
• Geben Sie die Vorhersageergebnisse an den Anforderer zurück

Den SageMaker-Konventionen folgend sind die ersten beiden Funktionen in implementiert input_fn Methode. Sehen Sie sich den folgenden Code an (der Einfachheit halber löschen wir einige Kommentarcodes):

def input_fn(request_body, request_content_type='application/json'):

    # --------------------- receive request ------------------------------------------------ #
    input_data = json.loads(request_body)

    subgraph_dict = input_data['graph']
    n_feats = input_data['n_feats']
    target_id = input_data['target_id']

    graph, new_n_feats, new_pred_target_id = recreate_graph_data(subgraph_dict, n_feats, target_id)

    return (graph, new_n_feats, new_pred_target_id)

Das konstruierte DGL-Diagramm und die Features werden dann an die übergeben predict_fn Methode zur Erfüllung der dritten Funktion. predict_fn nimmt zwei Eingabeargumente: die Ausgaben von input_fn und das trainierte Modell. Siehe folgenden Code:

def predict_fn(input_data, model):

    # ---------------------  Inference ------------------------------------------------ #
    graph, new_n_feats, new_pred_target_id = input_data

    with th.no_grad():
        logits = model(graph, new_n_feats)
        res = logits[new_pred_target_id].cpu().detach().numpy()

    return res[1]

Das verwendete Modell in perdict_fn wird von der erstellt model_fn -Methode, wenn der Endpunkt zum ersten Mal aufgerufen wird. Die Funktion model_fn lädt die gespeicherte Modelldatei und die zugehörigen Assets aus der model_dir -Argument und den SageMaker-Modellordner. Siehe folgenden Code:

def model_fn(model_dir):

    # ------------------ Loading model -------------------
    ntype_dict, etypes, in_size, hidden_size, out_size, n_layers, embedding_size = 
    initialize_arguments(os.path.join(BASE_PATH, 'metadata.pkl'))

    rgcn_model = HeteroRGCN(ntype_dict, etypes, in_size, hidden_size, out_size, n_layers, embedding_size)

    stat_dict = th.load('model.pth')

    rgcn_model.load_state_dict(stat_dict)

    return rgcn_model

Die Ausgabe der predict_fn Methode ist eine Liste mit zwei Zahlen, die die Logits für Klasse 0 und Klasse 1 angeben, wobei 0 legitim und 1 betrügerisch bedeutet. SageMaker nimmt diese Liste und übergibt sie an eine aufgerufene innere Methode output_fn um die letzte Funktion zu vervollständigen.

Um unser GNN-Modell bereitzustellen, verpacken wir zuerst das GNN-Modell in eine SageMaker-PyTorchModel-Klasse mit der Einstiegspunktdatei und anderen Parametern (dem Pfad der gespeicherten ZIP-Datei, der PyTorch-Framework-Version, der Python-Version usw.). Dann rufen wir seine Bereitstellungsmethode mit Instanzeinstellungen auf. Siehe folgenden Code:

env = {
    'SAGEMAKER_MODEL_SERVER_WORKERS': '1'
}

print(f'Use model {repackged_model_path}')

sagemakerSession = sm.session.Session(boto3.session.Session(region_name=current_region))
fd_sl_model = PyTorchModel(model_data=repackged_model_path, 
                           role=sagemaker_exec_role,
                           entry_point='./FD_SL_DGL/code/fd_sl_deployment_entry_point.py',
                           framework_version='1.6.0',
                           py_version='py3',
                           predictor_cls=JSONPredictor,
                           env=env,
                           sagemaker_session=sagemakerSession)
                           
fd_sl_predictor *=* fd_sl_model*.*deploy(instance_type*=*'ml.c5.4xlarge',
                                     initial_instance_count*=*1,)

Die vorstehenden Verfahren und Codeausschnitte zeigen, wie Sie Ihr GNN-Modell als Online-Inferenzendpunkt von einem Jupyter-Notebook aus bereitstellen. Für die Produktion empfehlen wir jedoch die Verwendung der zuvor erwähnten MLOps-Pipeline, die von Step Functions für den gesamten Workflow orchestriert wird, einschließlich der Verarbeitung von Daten, dem Trainieren des Modells und dem Bereitstellen eines Inferenzendpunkts. Die gesamte Pipeline wird von einem AWS CDK implementiert Anwendung, die einfach in verschiedenen Regionen und Konten repliziert werden kann.

Echtzeit-Inferenz

Wenn eine neue Transaktion eintrifft, müssen wir vier Schritte ausführen, um eine Echtzeitvorhersage durchzuführen:

1. Knoten- und Kanteneinfügung – Extrahieren Sie die Transaktionsinformationen wie Transaktions-ID und ProductCD als Knoten und Kanten und fügen Sie die neuen Knoten in die vorhandenen Diagrammdaten ein, die in der Neptune-Datenbank gespeichert sind.
2. Subgraph-Extraktion – Legen Sie den vorherzusagenden Transaktionsknoten als zentralen Knoten fest und extrahieren Sie einen n-Hop-Untergraphen gemäß den Eingabeanforderungen des GNN-Modells.
3. Feature-Extraktion – Extrahieren Sie für die Knoten und Kanten im Teilgraphen die zugehörigen Merkmale.
4. Rufen Sie den Inferenzendpunkt auf – Packen Sie den Untergraphen und die Features in den Inhalt einer Anfrage und senden Sie die Anfrage dann an den Inferenzendpunkt.

In dieser Lösung implementieren wir eine RESTful-API, um betrügerische Vorhersagen in Echtzeit zu erreichen, die in den vorherigen Schritten beschrieben wurden. Siehe den folgenden Pseudocode für Echtzeitvorhersagen. Die vollständige Umsetzung liegt vor die komplette Quellcodedatei.

Für Vorhersagen in Echtzeit erfordern die ersten drei Schritte eine geringere Latenz. Daher ist eine Graphdatenbank eine optimale Wahl für diese Aufgaben, insbesondere für die Teilgraphextraktion, die mit Graphdatenbankabfragen effizient erreicht werden könnte. Die Unterstreichungsfunktionen, die den Pseudocode unterstützen, basieren auf Neptuns Gremlin-Abfragen.

def handler(event, context):
    
    graph_input = GraphModelClient(endpoints)
    
    # Step 1: node and edge insertion
    trans_dict, identity_dict, target_id, transaction_value_cols, union_li_cols = 
        load_data_from_event(event, transactions_id_cols, transactions_cat_cols, dummied_col)
    graph_input.insert_new_transaction_vertex_and_edge(trans_dict, identity_dict , target_id, vertex_type = 'Transaction')
    
    
    # Setp 2: subgraph extraction
    subgraph_dict, transaction_embed_value_dict = 
        graph_input.query_target_subgraph(target_id, trans_dict, transaction_value_cols, union_li_cols, dummied_col)
    

    # Step 3 & 4: feature extraction & call the inference endpoint
    transaction_id = int(target_id[(target_id.find('-')+1):])
    pred_prob = invoke_endpoint_with_idx(endpointname = ENDPOINT_NAME, target_id = transaction_id, subgraph_dict = subgraph_dict, n_feats = transaction_embed_value_dict)
       
    function_res = {
                    'id': event['transaction_data'][0]['TransactionID'],
                    'flag': pred_prob > MODEL_BTW,
                    'pred_prob': pred_prob
                    }
       
    return function_res

Ein Vorbehalt bei der Echtzeit-Betrugserkennung mit GNNs ist der GNN-Inferenzmodus. Um die Echtzeit-Inferenz zu erfüllen, müssen wir die GNN-Modell-Inferenz vom transduktiven Modus in den induktiven Modus umwandeln. GNN-Modelle im transduktiven Inferenzmodus können keine Vorhersagen für neu aufgetretene Knoten und Kanten treffen, während GNN-Modelle im induktiven Modus neue Knoten und Kanten verarbeiten können. Eine Demonstration des Unterschieds zwischen transduktivem und induktivem Modus ist in der folgenden Abbildung dargestellt.

Im transduktiven Modus koexistieren vorhergesagte Knoten und Kanten mit markierten Knoten und Kanten während des Trainings. Modelle identifizieren sie vor der Inferenz, und sie könnten im Training abgeleitet werden. Modelle im induktiven Modus werden auf dem Trainingsdiagramm trainiert, müssen jedoch unsichtbare Knoten (die in rot gepunkteten Kreisen auf der rechten Seite) mit ihren zugehörigen Nachbarn vorhersagen, die neue Knoten sein können, wie der graue Dreiecksknoten auf der rechten Seite.

Unser RGCN-Modell wird im transduktiven Modus trainiert und getestet. Es hat Zugriff auf alle Knoten im Training und hat auch eine Einbettung für jeden funktionslosen Knoten trainiert, wie z. B. IP-Adresse und Kartentypen. In der Testphase verwendet das RGCN-Modell diese Einbettungen als Knotenmerkmale, um Knoten in der Testmenge vorherzusagen. Wenn wir jedoch Echtzeit-Inferenz durchführen, haben einige der neu hinzugefügten funktionslosen Knoten keine solchen Einbettungen, da sie nicht im Trainingsdiagramm enthalten sind. Eine Möglichkeit, dieses Problem anzugehen, besteht darin, den neuen Knoten den Mittelwert aller Einbettungen in denselben Knotentyp zuzuweisen. In dieser Lösung übernehmen wir diese Methode.

Darüber hinaus bietet diese Lösung ein Webportal (wie im folgenden Screenshot zu sehen), um betrügerische Vorhersagen in Echtzeit aus der Sicht von Geschäftsbetreibern zu demonstrieren. Es kann die simulierten Online-Transaktionen generieren und eine Live-Visualisierung der erkannten betrügerischen Transaktionsinformationen bereitstellen.

Aufräumen

Wenn Sie mit dem Erkunden der Lösung fertig sind, können Sie dies tun reinigen Sie die Ressourcen um Gebühren zu vermeiden.

Zusammenfassung

In diesem Beitrag haben wir gezeigt, wie Sie mit SageMaker, Neptune und DGL eine GNN-basierte Lösung zur Betrugserkennung in Echtzeit erstellen. Diese Lösung hat drei große Vorteile:

• Es hat eine gute Leistung in Bezug auf Vorhersagegenauigkeit und AUC-Metriken
• Es kann Echtzeit-Inferenzen über eine Streaming-MLOps-Pipeline und SageMaker-Endpunkte durchführen
• Es automatisiert den gesamten Bereitstellungsprozess mit der bereitgestellten CloudFormation-Vorlage, sodass interessierte Entwickler diese Lösung problemlos mit benutzerdefinierten Daten in ihrem Konto testen können

Weitere Details zur Lösung finden Sie unter GitHub Repo.

Nachdem Sie diese Lösung bereitgestellt haben, empfehlen wir, den Datenverarbeitungscode an Ihr eigenes Datenformat anzupassen und den Echtzeit-Inferenzmechanismus zu ändern, während das GNN-Modell unverändert bleibt. Beachten Sie, dass wir die Echtzeit-Inferenz ohne weitere Optimierung der Latenz in vier Schritte aufgeteilt haben. Diese vier Schritte dauern einige Sekunden, um eine Vorhersage für das Demo-Dataset zu erhalten. Wir glauben, dass die Optimierung des Neptune-Diagrammdatenschemadesigns und der Abfragen für die Subgraph- und Feature-Extraktion die Inferenzlatenz erheblich reduzieren kann.

Über die Autoren

Jian Zhang ist ein angewandter Wissenschaftler, der maschinelle Lerntechniken verwendet, um Kunden bei der Lösung verschiedener Probleme zu helfen, wie z. B. Betrugserkennung, Generierung von Dekorationsbildern und mehr. Er hat für Kunden in China, den USA und Singapur erfolgreich Lösungen für graphenbasiertes maschinelles Lernen, insbesondere graphische neuronale Netze, entwickelt. Als Aufklärer der Graphfunktionen von AWS hat Zhang viele öffentliche Präsentationen über das GNN, die Deep Graph Library (DGL), Amazon Neptune und andere AWS-Services gehalten.

Mengxin Zhu ist Manager von Solutions Architects bei AWS mit Schwerpunkt auf dem Design und der Entwicklung wiederverwendbarer AWS-Lösungen. Er ist seit vielen Jahren in der Softwareentwicklung tätig und verantwortete mehrere Startup-Teams unterschiedlicher Größe. Er ist auch ein Verfechter von Open-Source-Software und war ein Eclipse-Committer.

Haozhu Wang ist Forschungswissenschaftler bei Amazon ML Solutions Lab, wo er die Reinforcement Learning Vertical mitleitet. Er unterstützt Kunden beim Aufbau fortschrittlicher Lösungen für maschinelles Lernen mit den neuesten Forschungsergebnissen zu Graphenlernen, Verarbeitung natürlicher Sprache, Verstärkungslernen und AutoML. Haozhu promovierte in Elektro- und Computertechnik an der University of Michigan.