Le attività fraudolente hanno un grave impatto su molti settori, come l'e-commerce, i social media e i servizi finanziari. Le frodi potrebbero causare una perdita significativa per aziende e consumatori. I consumatori americani hanno riferito di aver perso oltre 5.8 miliardi di dollari a causa di frodi nel 2021, con un aumento di oltre il 70% rispetto al 2020. Molte tecniche sono state utilizzate per rilevare i truffatori: filtri basati su regole, rilevamento delle anomalie e modelli di machine learning (ML), solo per citarne alcuni.

Nei dati del mondo reale, le entità spesso implicano relazioni ricche con altre entità. Tale struttura grafica può fornire informazioni preziose per il rilevamento di anomalie. Ad esempio, nella figura seguente, gli utenti sono connessi tramite entità condivise come ID Wi-Fi, posizioni fisiche e numeri di telefono. A causa dell'elevato numero di valori univoci di queste entità, come i numeri di telefono, è difficile utilizzarli nei modelli tradizionali basati su funzionalità, ad esempio, la codifica one-hot di tutti i numeri di telefono non sarebbe praticabile. Ma tali relazioni potrebbero aiutare a prevedere se un utente è un truffatore. Se un utente ha condiviso diverse entità con un noto truffatore, è più probabile che l'utente sia un truffatore.

Recentemente, la rete neurale grafica (GNN) è diventata un metodo popolare per il rilevamento delle frodi. I modelli GNN possono combinare sia la struttura del grafico che gli attributi di nodi o bordi, come utenti o transazioni, per apprendere rappresentazioni significative per distinguere utenti ed eventi dannosi da quelli legittimi. Questa capacità è fondamentale per rilevare le frodi in cui i truffatori colludono per nascondere le loro caratteristiche anormali ma lasciano alcune tracce di relazioni.

Le attuali soluzioni GNN si basano principalmente sulla formazione batch offline e sulla modalità di inferenza, che rilevano i truffatori dopo che si sono verificati eventi dannosi e si sono verificate perdite. Tuttavia, catturare utenti e attività fraudolente in tempo reale è fondamentale per prevenire perdite. Ciò è particolarmente vero nei casi aziendali in cui esiste una sola possibilità di prevenire attività fraudolente. Ad esempio, in alcune piattaforme di e-commerce, la registrazione dell'account è completamente aperta. I truffatori possono comportarsi in modo dannoso solo una volta con un account e non utilizzare mai più lo stesso account.

È importante prevedere i truffatori in tempo reale. Costruire una soluzione del genere, tuttavia, è impegnativo. Poiché i GNN sono ancora una novità nel settore, ci sono risorse online limitate sulla conversione dei modelli GNN dalla pubblicazione in batch alla pubblicazione in tempo reale. Inoltre, è difficile costruire una pipeline di dati in streaming in grado di alimentare gli eventi in arrivo a un'API di servizio GNN in tempo reale. Al meglio delle conoscenze degli autori, al momento della stesura di questo documento non sono disponibili architetture ed esempi di riferimento per soluzioni di inferenza in tempo reale basate su GNN.

Per aiutare gli sviluppatori ad applicare i GNN al rilevamento delle frodi in tempo reale, questo post mostra come utilizzarli Amazon Nettuno, Amazon Sage Maker, e il Libreria Deep Graph (DGL), tra gli altri servizi AWS, per costruire una soluzione end-to-end per il rilevamento delle frodi in tempo reale utilizzando i modelli GNN.

Ci concentriamo su quattro compiti:

• Elaborazione di un set di dati di transazione tabulare in un set di dati grafico eterogeneo
• Addestrare un modello GNN utilizzando SageMaker
• Distribuzione dei modelli GNN addestrati come endpoint SageMaker
• Dimostrazione dell'inferenza in tempo reale per le transazioni in entrata

Questo post estende il lavoro precedente in Rilevamento di frodi in reti eterogenee utilizzando Amazon SageMaker e Deep Graph Library, che si concentra sulle prime due attività. Puoi fare riferimento a quel post per maggiori dettagli su grafici eterogenei, GNN e formazione semi-supervisionata di GNN.

Possono utilizzare anche le aziende che cercano un servizio AWS AI completamente gestito per il rilevamento delle frodi Amazon Fraud Detector, che semplifica l'identificazione di attività online potenzialmente fraudolente, come la creazione di account falsi o frodi di pagamento online.

Panoramica della soluzione

Questa soluzione contiene due parti principali.

La prima parte è una pipeline che elabora i dati, addestra i modelli GNN e distribuisce i modelli addestrati. Utilizza Colla AWS per elaborare i dati della transazione e salva i dati elaborati in entrambi Amazon Nettuno ed Servizio di archiviazione semplice Amazon (Amazon S3). Quindi, viene attivato un processo di formazione SageMaker per addestrare un modello GNN sui dati salvati in Amazon S3 per prevedere se una transazione è fraudolenta. Il modello addestrato insieme ad altre risorse vengono salvati su Amazon S3 al completamento del lavoro di formazione. Infine, il modello salvato viene distribuito come endpoint SageMaker. La pipeline è orchestrata da Funzioni AWS Step, come mostrato nella figura seguente.

La seconda parte della soluzione implementa il rilevamento delle transazioni fraudolente in tempo reale. Parte da un'API RESTful che interroga il database dei grafi in Neptune per estrarre il sottografo relativo a una transazione in entrata. Dispone inoltre di un portale web in grado di simulare attività commerciali, generando transazioni online sia fraudolente che legittime. Il portale web fornisce una visualizzazione in tempo reale del rilevamento delle frodi. Questa parte usa Amazon CloudFront, AWS Amplifica, AWS AppSync, Gateway API Amazon, Step Functions e AmazonDocumentDB per creare rapidamente l'applicazione web. Il diagramma seguente illustra il processo di inferenza in tempo reale e il portale web.

L'implementazione di questa soluzione, insieme a un AWS CloudFormazione modello che può avviare l'architettura nel tuo account AWS, è disponibile pubblicamente tramite quanto segue Repository GitHub.

Elaborazione dei dati

In questa sezione, descriviamo brevemente come elaborare un set di dati di esempio e convertirlo da tabelle grezze in un grafico con relazioni identificate tra diverse colonne.

Questa soluzione utilizza lo stesso set di dati, il Set di dati antifrode IEEE-CIS, come il post precedente Rilevamento di frodi in reti eterogenee utilizzando Amazon SageMaker e Deep Graph Library. Pertanto, il principio di base del trattamento dei dati è lo stesso. In breve, il set di dati sulle frodi include una tabella delle transazioni e una tabella delle identità, con quasi 500,000 record di transazioni anonimi insieme a informazioni contestuali (ad esempio, dispositivi utilizzati nelle transazioni). Alcune transazioni hanno un'etichetta binaria, che indica se una transazione è fraudolenta. Il nostro compito è prevedere quali transazioni senza etichetta sono fraudolente e quali legittime.

La figura seguente illustra il processo generale di conversione delle tabelle IEEE in un grafico eterogeneo. Per prima cosa estraiamo due colonne da ciascuna tabella. Una colonna è sempre la colonna dell'ID transazione, in cui impostiamo ogni TransactionID univoco come un nodo. Un'altra colonna viene prelevata dalle colonne categoriali, come le colonne ProductCD e id_03, in cui ogni categoria univoca è stata impostata come nodo. Se un TransactionID e una categoria univoca appaiono nella stessa riga, li colleghiamo a un bordo. In questo modo, convertiamo due colonne di una tabella in una bipartita. Quindi combiniamo quelle bipartiti con i nodi TransactionID, in cui gli stessi nodi TransactionID vengono uniti in un nodo univoco. Dopo questo passaggio, abbiamo un grafo eterogeneo costruito da bipartiti.

Per il resto delle colonne che non vengono utilizzate per costruire il grafico, le uniamo insieme come caratteristica dei nodi TransactionID. I valori TransactionID che hanno i valori isFraud vengono utilizzati come etichetta per l'addestramento del modello. Sulla base di questo grafico eterogeneo, il nostro compito diventa un compito di classificazione dei nodi dei nodi TransactionID. Per maggiori dettagli sulla preparazione dei dati del grafico per l'addestramento dei GNN, fare riferimento a Estrazione delle caratteristiche ed Costruire il grafico sezioni del post precedente del blog.

Il codice utilizzato in questa soluzione è disponibile in src/scripts/glue-etl.py. Puoi anche sperimentare l'elaborazione dei dati tramite il notebook Jupyter src/sagemaker/01.FD_SL_Process_IEEE-CIS_Dataset.ipynb.

Invece di elaborare manualmente i dati, come fatto nel post precedente, questa soluzione utilizza una pipeline completamente automatica orchestrata da Step Functions e AWS Glue che supporta l'elaborazione di enormi set di dati in parallelo tramite Apache Spark. Il flusso di lavoro di Step Functions è scritto Kit di sviluppo cloud AWS (AWS CDK). Quello che segue è un snippet di codice per creare questo flusso di lavoro:

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

Oltre a costruire i dati del grafico per l'addestramento del modello GNN, questo flusso di lavoro carica anche in batch i dati del grafico in Neptune per condurre un'inferenza in tempo reale in un secondo momento. Questo processo di caricamento dei dati batch è dimostrato nel seguente frammento di codice:

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

Formazione sul modello GNN

Dopo che i dati del grafico per l'addestramento del modello sono stati salvati in Amazon S3, a Lavoro di formazione SageMaker, che viene addebitato solo quando il processo di addestramento è in esecuzione, viene attivato per avviare il processo di addestramento del modello GNN nella modalità BYOC (Bring Your Own Container). Ti consente di impacchettare gli script di addestramento del modello e le dipendenze in un'immagine Docker, che utilizza per creare istanze di addestramento SageMaker. Il metodo BYOC potrebbe risparmiare uno sforzo significativo nella creazione dell'ambiente di formazione. In src/sagemaker/02.FD_SL_Build_Training_Container_Test_Local.ipynb, puoi trovare i dettagli della formazione del modello GNN.

Immagine Docker

La prima parte del file del notebook Jupyter è la generazione dell'immagine Docker di addestramento (vedere il frammento di codice seguente):

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

Abbiamo utilizzato un'immagine basata su PyTorch per l'addestramento del modello. La Deep Graph Library (DGL) e altre dipendenze vengono installate durante la creazione dell'immagine Docker. Il codice del modello GNN nel file src/sagemaker/FD_SL_DGL/gnn_fraud_detection_dgl anche la cartella viene copiata nell'immagine.

Poiché elaboriamo i dati della transazione in un grafico eterogeneo, in questa soluzione scegliamo il Grafico Relazionale Rete Convoluzionale (RGCN), progettato specificamente per grafici eterogenei. Il nostro modello RGCN può addestrare incorporamenti di apprendimento per i nodi in grafici eterogenei. Quindi, gli incorporamenti appresi vengono utilizzati come input di un livello completamente connesso per prevedere le etichette dei nodi.

iperparametri

Per addestrare il GNN, dobbiamo definire alcuni iperparametri prima del processo di training, come i nomi dei file del grafo costruito, il numero di strati dei modelli GNN, le epoche di training, l'ottimizzatore, i parametri di ottimizzazione e altro ancora. Vedere il codice seguente per un sottoinsieme delle configurazioni:

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}

Per ulteriori informazioni su tutti gli iperparametri e sui relativi valori predefiniti, vedere estimator_fns.py nel src/sagemaker/FD_SL_DGL/gnn_fraud_detection_dgl cartella.

Formazione modello con SageMaker

Dopo aver creato l'immagine Docker del contenitore personalizzata, utilizziamo i dati preelaborati per addestrare il nostro modello GNN con gli iperparametri che abbiamo definito. Il lavoro di formazione utilizza il DGL, con PyTorch come framework di deep learning di back-end, per costruire e addestrare il GNN. SageMaker semplifica il training di modelli GNN con l'immagine Docker personalizzata, che è un argomento di input dello stimatore SageMaker. Per ulteriori informazioni sull'addestramento dei GNN con il DGL su SageMaker, vedere Addestra una rete di grafici profondi.

L'SDK Python di SageMaker utilizza Estimator per incapsulare la formazione su SageMaker, che esegue contenitori Docker personalizzati compatibili con SageMaker, consentendoti di eseguire i tuoi algoritmi ML utilizzando SageMaker Python SDK. Il frammento di codice seguente mostra il training del modello con SageMaker (in un ambiente locale o in istanze cloud):

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)

Dopo l'addestramento, le prestazioni del modello GNN sul set di test vengono visualizzate come i seguenti output. Il modello RGCN normalmente può raggiungere circa 0.87 AUC e una precisione superiore al 95%. Per un confronto del modello RGCN con altri modelli ML, fare riferimento a Risultati sezione del post precedente del blog per maggiori dettagli.

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

Al completamento dell'addestramento del modello, SageMaker comprime il modello addestrato insieme ad altre risorse, inclusi gli incorporamenti dei nodi addestrati, in un file ZIP e quindi lo carica in una posizione S3 specificata. Successivamente, discutiamo dell'implementazione del modello addestrato per il rilevamento fraudolento in tempo reale.

Distribuzione del modello GNN

SageMaker semplifica la distribuzione di modelli ML addestrati. In questa fase, utilizziamo la classe SageMaker PyTorchModel per distribuire il modello addestrato, poiché il nostro modello DGL dipende da PyTorch come framework di back-end. Puoi trovare il codice di distribuzione in src/sagemaker/03.FD_SL_Endpoint_Deployment.ipynb file.

Oltre al file del modello addestrato e alle risorse, SageMaker richiede un file del punto di ingresso per la distribuzione di un modello personalizzato. Il file del punto di ingresso viene eseguito e archiviato nella memoria di un'istanza dell'endpoint di inferenza per rispondere alla richiesta di inferenza. Nel nostro caso, il file del punto di ingresso è il fd_sl_deployment_entry_point.py file nella src/sagemaker/FD_SL_DGL/code cartella, che svolge quattro funzioni principali:

• Ricevi richieste e analizza il contenuto delle richieste per ottenere i nodi da prevedere e i dati associati
• Converti i dati in un grafico eterogeneo DGL come input per il modello RGCN
• Eseguire l'inferenza in tempo reale tramite il modello RGCN addestrato
• Restituire i risultati della previsione al richiedente

Seguendo le convenzioni di SageMaker, le prime due funzioni sono implementate nel input_fn metodo. Vedere il codice seguente (per semplicità eliminiamo alcuni codici di commento):

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)

Il grafico e le caratteristiche DGL costruiti vengono quindi passati a predict_fn metodo per svolgere la terza funzione. predict_fn accetta due argomenti di input: gli output di input_fn e il modello addestrato. Vedere il codice seguente:

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]

Il modello utilizzato in perdict_fn viene creato da model_fn metodo quando l'endpoint viene chiamato la prima volta. La funzione model_fn carica il file del modello salvato e le risorse associate dal file model_dir argomento e la cartella del modello SageMaker. Vedere il codice seguente:

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

L'output di predict_fn metodo è un elenco di due numeri, che indica i logit per la classe 0 e la classe 1, dove 0 significa legittimo e 1 significa fraudolento. SageMaker prende questo elenco e lo passa a un metodo interno chiamato output_fn per completare la funzione finale.

Per distribuire il nostro modello GNN, avvolgiamo prima il modello GNN in una classe SageMaker PyTorchModel con il file del punto di ingresso e altri parametri (il percorso del file ZIP salvato, la versione del framework PyTorch, la versione Python e così via). Quindi chiamiamo il suo metodo di distribuzione con le impostazioni dell'istanza. Vedere il codice seguente:

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

Le procedure e i frammenti di codice precedenti illustrano come distribuire il modello GNN come endpoint di inferenza online da un notebook Jupyter. Tuttavia, per la produzione, consigliamo di usare la pipeline MLOps precedentemente menzionata orchestrata da Step Functions per l'intero flusso di lavoro, inclusi l'elaborazione dei dati, il training del modello e la distribuzione di un endpoint di inferenza. L'intera pipeline è implementata da un AWS CDK applicazione, che può essere facilmente replicato in diverse regioni e account.

Inferenza in tempo reale

Quando arriva una nuova transazione, per eseguire la previsione in tempo reale, dobbiamo completare quattro passaggi:

1. Inserimento di nodi e spigoli – Estrarre le informazioni della transazione come TransactionID e ProductCD come nodi e bordi e inserire i nuovi nodi nei dati del grafico esistenti archiviati nel database Neptune.
2. Estrazione del sottografo – Impostare il nodo della transazione da prevedere come nodo centrale ed estrarre un sottografo n-hop in base ai requisiti di input del modello GNN.
3. Estrazione delle caratteristiche – Per i nodi e gli spigoli nel sottografo, estrai le loro caratteristiche associate.
4. Chiama l'endpoint di inferenza – Inserisci il sottografo e le funzionalità nel contenuto di una richiesta, quindi invia la richiesta all'endpoint di inferenza.

In questa soluzione, implementiamo un'API RESTful per ottenere la previsione fraudolenta in tempo reale descritta nei passaggi precedenti. Vedere il seguente pseudocodice per previsioni in tempo reale. La piena attuazione è in il file di codice sorgente completo.

Per la previsione in tempo reale, i primi tre passaggi richiedono una latenza inferiore. Pertanto, un database di grafi è una scelta ottimale per queste attività, in particolare per l'estrazione di sottografi, che potrebbe essere ottenuta in modo efficiente con query di database di grafi. Le funzioni di sottolineatura che supportano lo pseudo-codice sono basate sulle query gremlin di Neptune.

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

Un avvertimento sul rilevamento delle frodi in tempo reale tramite GNN è la modalità di inferenza GNN. Per soddisfare l'inferenza in tempo reale, dobbiamo convertire l'inferenza del modello GNN dalla modalità trasduttiva alla modalità induttiva. I modelli GNN in modalità di inferenza trasduttiva non possono fare previsioni per nodi e bordi appena apparsi, mentre in modalità induttiva, i modelli GNN possono gestire nuovi nodi e bordi. Una dimostrazione della differenza tra modalità trasduttiva e induttiva è mostrata nella figura seguente.

In modalità trasduttiva, i nodi e gli spigoli previsti coesistono con i nodi e gli spigoli etichettati durante l'allenamento. I modelli li identificano prima dell'inferenza e potrebbero essere dedotti durante l'addestramento. I modelli in modalità induttiva vengono addestrati sul grafico di addestramento ma devono prevedere i nodi invisibili (quelli nei cerchi tratteggiati rossi a destra) con i loro vicini associati, che potrebbero essere nuovi nodi, come il nodo del triangolo grigio a destra.

Il nostro modello RGCN è addestrato e testato in modalità trasduttiva. Ha accesso a tutti i nodi in formazione e ha anche addestrato un'incorporamento per ogni nodo senza funzionalità, come l'indirizzo IP e i tipi di scheda. Nella fase di test, il modello RGCN utilizza questi incorporamenti come funzionalità dei nodi per prevedere i nodi nel set di test. Quando eseguiamo l'inferenza in tempo reale, tuttavia, alcuni dei nodi senza funzionalità appena aggiunti non hanno tali incorporamenti perché non sono nel grafico di addestramento. Un modo per affrontare questo problema consiste nell'assegnare la media di tutti gli incorporamenti nello stesso tipo di nodo ai nuovi nodi. In questa soluzione, adottiamo questo metodo.

Inoltre, questa soluzione fornisce un portale Web (come mostrato nella schermata seguente) per dimostrare previsioni fraudolente in tempo reale dal punto di vista degli operatori del settore. Può generare le transazioni online simulate e fornire una visualizzazione in tempo reale delle informazioni sulle transazioni fraudolente rilevate.

ripulire

Quando hai finito di esplorare la soluzione, puoi pulire le risorse per evitare di incorrere in spese.

Conclusione

In questo post, abbiamo mostrato come creare una soluzione di rilevamento delle frodi in tempo reale basata su GNN utilizzando SageMaker, Neptune e DGL. Questa soluzione presenta tre vantaggi principali:

• Ha buone prestazioni in termini di precisione di previsione e metriche AUC
• Può eseguire l'inferenza in tempo reale tramite una pipeline MLOps in streaming e gli endpoint SageMaker
• Automatizza il processo di distribuzione totale con il modello CloudFormation fornito in modo che gli sviluppatori interessati possano testare facilmente questa soluzione con dati personalizzati nel proprio account

Per maggiori dettagli sulla soluzione, vedere il Repository GitHub.

Dopo aver distribuito questa soluzione, ti consigliamo di personalizzare il codice di elaborazione dei dati per adattarlo al tuo formato di dati e modificare il meccanismo di inferenza in tempo reale mantenendo invariato il modello GNN. Si noti che abbiamo suddiviso l'inferenza in tempo reale in quattro passaggi senza un'ulteriore ottimizzazione della latenza. Questi quattro passaggi richiedono alcuni secondi per ottenere una previsione sul set di dati demo. Riteniamo che l'ottimizzazione della progettazione dello schema dei dati del grafico di Neptune e delle query per l'estrazione di sottografi e funzionalità possa ridurre significativamente la latenza dell'inferenza.

Circa gli autori

Jian Zhang è uno scienziato applicato che ha utilizzato tecniche di apprendimento automatico per aiutare i clienti a risolvere vari problemi, come il rilevamento di frodi, la generazione di immagini decorative e altro ancora. Ha sviluppato con successo l'apprendimento automatico basato su grafi, in particolare reti neurali grafiche, soluzioni per clienti in Cina, USA e Singapore. In quanto illuminante delle capacità dei grafici di AWS, Zhang ha tenuto molte presentazioni pubbliche su GNN, Deep Graph Library (DGL), Amazon Neptune e altri servizi AWS.

Mengxin Zhu è un manager di Solutions Architects presso AWS, con particolare attenzione alla progettazione e allo sviluppo di soluzioni AWS riutilizzabili. Da molti anni si occupa di sviluppo software ed è stato responsabile di diversi team di startup di varie dimensioni. È anche un sostenitore del software open source ed è stato un Eclipse Committer.

Haozhu Wang è ricercatore presso Amazon ML Solutions Lab, dove co-dirige il Reinforcement Learning Vertical. Aiuta i clienti a creare soluzioni avanzate di machine learning con le ultime ricerche sull'apprendimento dei grafi, l'elaborazione del linguaggio naturale, l'apprendimento per rinforzo e AutoML. Haozhu ha conseguito il dottorato di ricerca in Ingegneria Elettrica e Informatica presso l'Università del Michigan.