Bouw een op GNN gebaseerde realtime fraudedetectieoplossing met Amazon SageMaker, Amazon Neptune en de Deep Graph Library

Frauduleuze activiteiten hebben ernstige gevolgen voor veel sectoren, zoals e-commerce, sociale media en financiële diensten. Fraude kan aanzienlijke schade veroorzaken voor bedrijven en consumenten. Amerikaanse consumenten meldden dat ze in 5.8 meer dan $ 2021 miljard aan fraude hebben verloren, een stijging van meer dan 70% ten opzichte van 2020. Er zijn veel technieken gebruikt om fraudeurs te detecteren: op regels gebaseerde filters, anomaliedetectie en modellen voor machine learning (ML), om er maar een paar te noemen.

In real-world gegevens hebben entiteiten vaak rijke relaties met andere entiteiten. Een dergelijke grafiekstructuur kan waardevolle informatie opleveren voor de detectie van afwijkingen. In de volgende afbeelding zijn gebruikers bijvoorbeeld verbonden via gedeelde entiteiten zoals wifi-ID's, fysieke locaties en telefoonnummers. Vanwege het grote aantal unieke waarden van deze entiteiten, zoals telefoonnummers, is het moeilijk om ze te gebruiken in de traditionele op functies gebaseerde modellen. Zo zou one-hot-codering van alle telefoonnummers niet haalbaar zijn. Maar dergelijke relaties kunnen helpen voorspellen of een gebruiker een fraudeur is. Als een gebruiker meerdere entiteiten heeft gedeeld met een bekende fraudeur, is de kans groter dat de gebruiker een fraudeur is.

De laatste tijd is Graph Neural Network (GNN) een populaire methode geworden voor fraudedetectie. GNN-modellen kunnen zowel de grafiekstructuur als attributen van knooppunten of randen, zoals gebruikers of transacties, combineren om zinvolle representaties te leren om kwaadwillende gebruikers en gebeurtenissen te onderscheiden van legitieme. Deze mogelijkheid is cruciaal voor het detecteren van fraude waarbij fraudeurs samenspannen om hun abnormale kenmerken te verbergen, maar sporen van relaties achter te laten.

De huidige GNN-oplossingen zijn voornamelijk gebaseerd op offline batchtraining en inferentiemodus, die fraudeurs detecteren nadat kwaadaardige gebeurtenissen hebben plaatsgevonden en verliezen hebben plaatsgevonden. Het in realtime opsporen van frauduleuze gebruikers en activiteiten is echter cruciaal om verliezen te voorkomen. Dit geldt met name in business cases waar er maar één kans is om frauduleuze activiteiten te voorkomen. In sommige e-commerceplatforms is accountregistratie bijvoorbeeld wijd open. Fraudeurs kunnen zich slechts één keer kwaadaardig gedragen met een account en nooit meer hetzelfde account gebruiken.

Het is belangrijk om fraudeurs in realtime te voorspellen. Het bouwen van een dergelijke oplossing is echter een uitdaging. Omdat GNN's nog nieuw zijn in de branche, zijn er beperkte online bronnen voor het converteren van GNN-modellen van batch-serving naar realtime-serving. Bovendien is het een uitdaging om een ​​pijplijn voor streaminggegevens te bouwen die inkomende gebeurtenissen naar een GNN realtime-serving-API kan voeren. Voor zover de auteurs weten, zijn er op het moment van schrijven geen referentiearchitecturen en voorbeelden beschikbaar voor op GNN gebaseerde realtime inferentieoplossingen.

Om ontwikkelaars te helpen GNN's toe te passen op realtime fraudedetectie, laat dit bericht zien hoe u dit kunt gebruiken Amazone Neptunus, Amazon Sage MakerEn Diepe Grafiekbibliotheek (DGL), naast andere AWS-services, om een ​​end-to-end-oplossing te bouwen voor realtime fraudedetectie met behulp van GNN-modellen.

We richten ons op vier taken:

• Een transactiegegevensset in tabelvorm verwerken tot een heterogene grafiekgegevensset
• Een GNN-model trainen met SageMaker
• De getrainde GNN-modellen implementeren als een SageMaker-eindpunt
• Aantonen van realtime gevolgtrekkingen voor inkomende transacties

Dit bericht verlengt het vorige werk in Detectie van fraude in heterogene netwerken met Amazon SageMaker en Deep Graph Library, die zich richt op de eerste twee taken. U kunt naar dat bericht verwijzen voor meer informatie over heterogene grafieken, GNN's en semi-gesuperviseerde training van GNN's.

Bedrijven die op zoek zijn naar een volledig beheerde AWS AI-service voor fraudedetectie, kunnen ook gebruikmaken van Amazone fraude detector, waardoor het mogelijk is om potentieel frauduleuze online activiteiten te identificeren, zoals het aanmaken van nepaccounts of online betalingsfraude.

Overzicht oplossingen

Deze oplossing bevat twee grote delen.

Het eerste deel is een pijplijn die de gegevens verwerkt, GNN-modellen traint en de getrainde modellen implementeert. Het gebruikt AWS lijm om de transactiegegevens te verwerken, en slaat de verwerkte gegevens op in beide Amazone Neptunus en Amazon eenvoudige opslagservice (Amazon S3). Vervolgens wordt een SageMaker-trainingstaak geactiveerd om een ​​GNN-model te trainen op de gegevens die zijn opgeslagen in Amazon S3 om te voorspellen of een transactie frauduleus is. Het getrainde model wordt samen met andere middelen weer opgeslagen op Amazon S3 na voltooiing van de trainingstaak. Ten slotte wordt het opgeslagen model geïmplementeerd als een SageMaker-eindpunt. De pijplijn wordt georkestreerd door: AWS Stap Functies, zoals weergegeven in de volgende afbeelding.

Het tweede deel van de oplossing implementeert realtime detectie van frauduleuze transacties. Het begint met een RESTful API die de grafiekdatabase in Neptune doorzoekt om de subgrafiek met betrekking tot een inkomende transactie te extraheren. Het heeft ook een webportaal dat zakelijke activiteiten kan simuleren en online transacties kan genereren met zowel frauduleuze als legitieme transacties. Het webportaal biedt een live visualisatie van de fraudedetectie. Dit deel gebruikt Amazon CloudFront, AWS versterken, AWS AppSync, Amazon API-gateway, Stapfuncties en Amazon DocumentDB om de webapplicatie snel te bouwen. Het volgende diagram illustreert het realtime inferentieproces en de webportal.

De implementatie van deze oplossing, samen met een AWS CloudFormatie sjabloon die de architectuur in uw AWS-account kan starten, is openbaar beschikbaar via het volgende: GitHub repo.

Gegevensverwerking

In deze sectie beschrijven we kort hoe u een voorbeeldgegevensset kunt verwerken en deze kunt converteren van onbewerkte tabellen naar een grafiek met relaties tussen verschillende kolommen.

Deze oplossing gebruikt dezelfde dataset, de IEEE-CIS-fraudegegevensset, zoals de vorige post Detectie van fraude in heterogene netwerken met Amazon SageMaker en Deep Graph Library. Daarom is het basisprincipe van het gegevensproces hetzelfde. Kort gezegd omvat de fraudedataset een transactietabel en een identiteitstabel, met bijna 500,000 geanonimiseerde transactierecords samen met contextuele informatie (bijvoorbeeld apparaten die bij transacties worden gebruikt). Sommige transacties hebben een binair label dat aangeeft of een transactie frauduleus is. Het is onze taak om te voorspellen welke transacties zonder label frauduleus zijn en welke legitiem zijn.

De volgende afbeelding illustreert het algemene proces voor het converteren van de IEEE-tabellen naar een heterogene grafiek. We extraheren eerst twee kolommen uit elke tabel. Eén kolom is altijd de transactie-ID-kolom, waarbij we elke unieke TransactionID als één knooppunt instellen. Een andere kolom wordt gekozen uit de categorische kolommen, zoals de kolommen ProductCD en id_03, waarbij elke unieke categorie als een knooppunt is ingesteld. Als een TransactionID en een unieke categorie in dezelfde rij voorkomen, verbinden we ze met één edge. Op deze manier zetten we twee kolommen in een tabel om in één bipartiete. Vervolgens combineren we die bipartites samen met de TransactionID-knooppunten, waarbij dezelfde TransactionID-knooppunten worden samengevoegd tot één uniek knooppunt. Na deze stap hebben we een heterogene grafiek opgebouwd uit bipartites.

Voor de rest van de kolommen die niet worden gebruikt om de grafiek te bouwen, voegen we ze samen als de functie van de TransactionID-knooppunten. TransactionID-waarden die de isFraud-waarden hebben, worden gebruikt als label voor modeltraining. Op basis van deze heterogene grafiek wordt onze taak een knooppuntclassificatietaak van de TransactionID-knooppunten. Voor meer details over het voorbereiden van de grafiekgegevens voor het trainen van GNN's, raadpleeg de: Feature extractie en De grafiek construeren delen van de vorige blogpost.

De code die in deze oplossing wordt gebruikt, is beschikbaar in: src/scripts/glue-etl.py. U kunt ook experimenteren met gegevensverwerking via het Jupyter-notebook src/sagemaker/01.FD_SL_Process_IEEE-CIS_Dataset.ipynb.

In plaats van de gegevens handmatig te verwerken, zoals in het vorige bericht, gebruikt deze oplossing een volledig automatische pijplijn die wordt georkestreerd door Step Functions en AWS Glue en die ondersteuning biedt voor het parallel verwerken van enorme datasets via Apache Spark. De workflow Step Functions is geschreven in: AWS Cloud-ontwikkelingskit (AWS CDK). Het volgende is een codefragment om deze werkstroom te maken:

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);

Naast het construeren van de grafiekgegevens voor GNN-modeltraining, laadt deze workflow ook batchgewijs de grafiekgegevens in Neptune om later realtime gevolgtrekkingen uit te voeren. Dit laadproces voor batchgegevens wordt gedemonstreerd in het volgende codefragment:

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

Nadat de grafiekgegevens voor modeltraining zijn opgeslagen in Amazon S3, a SageMaker-trainingsbaan, die alleen in rekening wordt gebracht wanneer de trainingstaak wordt uitgevoerd, wordt geactiveerd om het GNN-modeltrainingsproces te starten in de modus Bring Your Own Container (BYOC). Hiermee kunt u uw modeltrainingsscripts en -afhankelijkheden in een Docker-image inpakken, die het gebruikt om SageMaker-trainingsinstanties te maken. De BYOC-methode kan aanzienlijke inspanningen besparen bij het opzetten van de trainingsomgeving. In src/sagemaker/02.FD_SL_Build_Training_Container_Test_Local.ipynb, vindt u details over de GNN-modeltraining.

Docker-afbeelding

Het eerste deel van het Jupyter-notebookbestand is de training Docker-afbeeldingsgeneratie (zie het volgende codefragment):

*!* 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

We hebben een op PyTorch gebaseerde afbeelding gebruikt voor de modeltraining. De Deep Graph Library (DGL) en andere afhankelijkheden worden geïnstalleerd bij het bouwen van de Docker-image. De GNN-modelcode in de src/sagemaker/FD_SL_DGL/gnn_fraud_detection_dgl map wordt ook naar de afbeelding gekopieerd.

Omdat we de transactiegegevens verwerken tot een heterogene grafiek, kiezen we in deze oplossing voor de Relationele grafiek convolutienetwerk (RGCN) -model, dat speciaal is ontworpen voor heterogene grafieken. Ons RGCN-model kan leerbare inbeddingen voor de knooppunten in heterogene grafieken trainen. Vervolgens worden de geleerde inbeddingen gebruikt als invoer van een volledig verbonden laag voor het voorspellen van de knooppuntlabels.

Hyperparameters

Om de GNN te trainen, moeten we een paar hyperparameters definiëren vóór het trainingsproces, zoals de bestandsnamen van de geconstrueerde grafiek, het aantal lagen van GNN-modellen, de trainingstijdvakken, de optimizer, de optimalisatieparameters en meer. Zie de volgende code voor een subset van de configuraties:

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}

Voor meer informatie over alle hyperparameters en hun standaardwaarden, zie estimator_fns.py in de src/sagemaker/FD_SL_DGL/gnn_fraud_detection_dgl map.

Modeltraining met SageMaker

Nadat de aangepaste container Docker-image is gebouwd, gebruiken we de voorverwerkte gegevens om ons GNN-model te trainen met de hyperparameters die we hebben gedefinieerd. De trainingstaak gebruikt de DGL, met PyTorch als het backend deep learning-framework, om de GNN te bouwen en te trainen. SageMaker maakt het gemakkelijk om GNN-modellen te trainen met de aangepaste Docker-afbeelding, wat een invoerargument is van de SageMaker-schatter. Voor meer informatie over het trainen van GNN's met de DGL op SageMaker, zie: Train een Deep Graph Network.

De SageMaker Python SDK gebruikt: Taxateur om training in te kapselen op SageMaker, die SageMaker-compatibele aangepaste Docker-containers uitvoert, zodat u uw eigen ML-algoritmen kunt uitvoeren met behulp van de SageMaker Python SDK. Het volgende codefragment demonstreert het trainen van het model met SageMaker (in een lokale omgeving of cloudinstanties):

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)

Na de training worden de prestaties van het GNN-model op de testset weergegeven zoals de volgende outputs. Het RGCN-model kan normaal gesproken ongeveer 0.87 AUC en een nauwkeurigheid van meer dan 95% bereiken. Voor een vergelijking van het RGCN-model met andere ML-modellen, raadpleeg de: Resultaten gedeelte van de vorige blogpost voor meer informatie.

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

Na voltooiing van de modeltraining verpakt SageMaker het getrainde model samen met andere middelen, inclusief de getrainde node-inbeddingen, in een ZIP-bestand en uploadt het het vervolgens naar een gespecificeerde S3-locatie. Vervolgens bespreken we de inzet van het getrainde model voor realtime fraudedetectie.

GNN-modelimplementatie

SageMaker maakt de inzet van getrainde ML-modellen eenvoudig. In deze fase gebruiken we de SageMaker PyTorchModel-klasse om het getrainde model te implementeren, omdat ons DGL-model afhankelijk is van PyTorch als het backend-framework. U vindt de implementatiecode in de src/sagemaker/03.FD_SL_Endpoint_Deployment.ipynb bestand.

Naast het getrainde modelbestand en de activa, heeft SageMaker een ingangspuntbestand nodig voor de implementatie van een aangepast model. Het ingangspuntbestand wordt uitgevoerd en opgeslagen in het geheugen van een inferentie-eindpuntinstantie om te reageren op de inferentieaanvraag. In ons geval is het ingangspuntbestand de fd_sl_deployment_entry_point.py bestand in de src/sagemaker/FD_SL_DGL/code map, die vier belangrijke functies vervult:

• Verzoeken ontvangen en de inhoud van verzoeken ontleden om de te voorspellen knooppunten en de bijbehorende gegevens te verkrijgen
• Converteer de gegevens naar een heterogene DGL-grafiek als invoer voor het RGCN-model
• Voer de realtime gevolgtrekking uit via het getrainde RGCN-model
• Stuur de voorspellingsresultaten terug naar de aanvrager

Volgens SageMaker-conventies zijn de eerste twee functies geïmplementeerd in de: input_fn methode. Zie de volgende code (voor de eenvoud verwijderen we enkele commentaarcode):

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)

De geconstrueerde DGL-grafiek en kenmerken worden vervolgens doorgegeven aan de predict_fn methode om de derde functie te vervullen. predict_fn heeft twee invoerargumenten nodig: de uitvoer van input_fn en het getrainde model. Zie de volgende 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]

Het model dat wordt gebruikt in perdict_fn is gemaakt door de model_fn methode wanneer het eindpunt de eerste keer wordt aangeroepen. De functie model_fn laadt het opgeslagen modelbestand en de bijbehorende activa van de model_dir argument en de SageMaker-modelmap. Zie de volgende 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

De output van de predict_fn methode is een lijst van twee getallen, die de logits voor klasse 0 en klasse 1 aangeven, waarbij 0 legitiem betekent en 1 frauduleus. SageMaker neemt deze lijst en geeft deze door aan een innerlijke methode genaamd output_fn om de laatste functie te voltooien.

Om ons GNN-model te implementeren, wikkelen we het GNN-model eerst in een SageMaker PyTorchModel-klasse met het ingangspuntbestand en andere parameters (het pad van het opgeslagen ZIP-bestand, de PyTorch-frameworkversie, de Python-versie, enzovoort). Vervolgens noemen we de implementatiemethode met instantie-instellingen. Zie de volgende 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,)

De voorgaande procedures en codefragmenten laten zien hoe u uw GNN-model implementeert als een online inferentie-eindpunt vanaf een Jupyter-notebook. Voor productie raden we echter aan om de eerder genoemde MLOps-pijplijn te gebruiken die is georkestreerd door Step Functions voor de hele werkstroom, inclusief het verwerken van gegevens, het trainen van het model en het implementeren van een inferentie-eindpunt. De gehele pijplijn wordt geïmplementeerd door een AWS CDK toepassing, die gemakkelijk kan worden gerepliceerd in verschillende regio's en accounts.

Real-time gevolgtrekking

Wanneer een nieuwe transactie binnenkomt, moeten we vier stappen uitvoeren om realtime voorspellingen uit te voeren:

1. Knooppunt en rand invoegen – Extraheer de transactie-informatie zoals de TransactionID en ProductCD als knooppunten en randen, en voeg de nieuwe knooppunten in de bestaande grafiekgegevens die zijn opgeslagen in de Neptune-database.
2. Subgraaf extractie – Stel het te voorspellen transactieknooppunt in als het middelste knooppunt en extraheer een n-hop-subgrafiek volgens de invoervereisten van het GNN-model.
3. Feature extractie – Extraheer voor de knopen en randen in de subgraaf de bijbehorende kenmerken.
4. Bel het inferentie-eindpunt – Verpak de subgrafiek en functies in de inhoud van een verzoek en stuur het verzoek vervolgens naar het inferentie-eindpunt.

In deze oplossing implementeren we een RESTful API om realtime frauduleuze voorspellingen te bereiken die in de voorgaande stappen zijn beschreven. Zie de volgende pseudo-code voor realtime voorspellingen. De volledige implementatie is binnen het volledige broncodebestand.

Voor voorspelling in realtime vereisen de eerste drie stappen een lagere latentie. Daarom is een graafdatabase een optimale keuze voor deze taken, met name voor de subgraafextractie, die efficiënt kan worden bereikt met graafdatabasequery's. De onderstrepingsfuncties die de pseudo-code ondersteunen, zijn gebaseerd op de gremlin-query's van Neptunus.

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

Een voorbehoud bij realtime fraudedetectie met behulp van GNN's is de GNN-inferentiemodus. Om real-time gevolgtrekkingen te vervullen, moeten we de GNN-modelinferentie omzetten van transductieve modus naar inductieve modus. GNN-modellen in transductieve inferentiemodus kunnen geen voorspellingen doen voor nieuw verschenen knooppunten en randen, terwijl in inductieve modus GNN-modellen nieuwe knooppunten en randen aankunnen. Een demonstratie van het verschil tussen transductieve en inductieve modus wordt getoond in de volgende afbeelding.

In de transductieve modus bestaan ​​voorspelde knooppunten en randen naast gelabelde knooppunten en randen tijdens de training. Modellen identificeren ze vóór gevolgtrekking, en ze kunnen worden afgeleid tijdens de training. Modellen in inductieve modus worden getraind op de trainingsgrafiek, maar moeten onzichtbare knooppunten (die in rode gestippelde cirkels aan de rechterkant) met hun bijbehorende buren voorspellen, wat nieuwe knooppunten kunnen zijn, zoals het grijze driehoekige knooppunt aan de rechterkant.

Ons RGCN-model is getraind en getest in transductieve modus. Het heeft toegang tot alle knooppunten in training en heeft ook een inbedding getraind voor elk knooppunt zonder functies, zoals IP-adres en kaarttypen. In de testfase gebruikt het RGCN-model deze inbeddingen als knooppuntfuncties om knooppunten in de testset te voorspellen. Wanneer we echter realtime gevolgtrekking maken, hebben sommige van de nieuw toegevoegde functieloze knooppunten dergelijke inbeddingen niet omdat ze niet in de trainingsgrafiek staan. Een manier om dit probleem aan te pakken is om het gemiddelde van alle inbeddingen in hetzelfde knooppunttype toe te wijzen aan de nieuwe knooppunten. In deze oplossing passen we deze methode toe.

Bovendien biedt deze oplossing een webportaal (zoals te zien is in de volgende schermafbeelding) om realtime frauduleuze voorspellingen vanuit het perspectief van bedrijfsexploitanten aan te tonen. Het kan de gesimuleerde online transacties genereren en een live visualisatie bieden van gedetecteerde frauduleuze transactie-informatie.

Opruimen

Wanneer u klaar bent met het verkennen van de oplossing, kunt u: maak de middelen schoon om kosten te voorkomen.

Conclusie

In dit bericht hebben we laten zien hoe u een op GNN gebaseerde realtime fraudedetectieoplossing kunt bouwen met SageMaker, Neptune en de DGL. Deze oplossing heeft drie grote voordelen:

• Het heeft goede prestaties op het gebied van voorspellingsnauwkeurigheid en AUC-statistieken
• Het kan realtime gevolgtrekkingen uitvoeren via een streaming MLOps-pijplijn en SageMaker-eindpunten
• Het automatiseert het totale implementatieproces met de meegeleverde CloudFormation-sjabloon, zodat geïnteresseerde ontwikkelaars deze oplossing eenvoudig kunnen testen met aangepaste gegevens in hun account

Voor meer details over de oplossing, zie de GitHub repo.

Nadat u deze oplossing hebt geïmplementeerd, raden we aan de gegevensverwerkingscode aan te passen aan uw eigen gegevensindeling en het realtime-inferentiemechanisme aan te passen terwijl het GNN-model ongewijzigd blijft. Merk op dat we de realtime gevolgtrekking in vier stappen hebben opgesplitst zonder verdere optimalisatie van de latentie. Deze vier stappen nemen een paar seconden in beslag om een ​​voorspelling op de demogegevensset te krijgen. We zijn van mening dat het optimaliseren van het Neptune-grafiekgegevensschema-ontwerp en query's voor subgrafiek- en functie-extractie de inferentielatentie aanzienlijk kan verminderen.

Over de auteurs

Jian Zhang is een toegepaste wetenschapper die machine learning-technieken heeft gebruikt om klanten te helpen bij het oplossen van verschillende problemen, zoals fraudedetectie, het genereren van decoratieafbeeldingen en meer. Hij heeft met succes op grafieken gebaseerde machine learning ontwikkeld, met name neuraal netwerk voor grafieken, oplossingen voor klanten in China, de VS en Singapore. Als een voorlichter van de grafische mogelijkheden van AWS heeft Zhang veel openbare presentaties gegeven over de GNN, de Deep Graph Library (DGL), Amazon Neptune en andere AWS-services.

Mengxin Zhu is manager Solutions Architects bij AWS, met een focus op het ontwerpen en ontwikkelen van herbruikbare AWS-oplossingen. Hij is al vele jaren bezig met softwareontwikkeling en was verantwoordelijk voor verschillende startup-teams van verschillende groottes. Hij is ook een voorstander van open-source software en was een Eclipse Committer.

Haozhu Wang is onderzoekswetenschapper bij Amazon ML Solutions Lab, waar hij mede-leider is van de Reinforcement Learning Vertical. Hij helpt klanten bij het bouwen van geavanceerde machine learning-oplossingen met het nieuwste onderzoek naar het leren van grafieken, natuurlijke taalverwerking, versterkend leren en AutoML. Haozhu behaalde zijn PhD in Electrical and Computer Engineering aan de University of Michigan.