Construiți o soluție de detectare a fraudei în timp real bazată pe GNN folosind Amazon SageMaker, Amazon Neptune și Deep Graph Library

Activitățile frauduloase au un impact grav asupra multor industrii, cum ar fi comerțul electronic, rețelele sociale și serviciile financiare. Fraudele ar putea cauza o pierdere semnificativă pentru întreprinderi și consumatori. Consumatorii americani au raportat că au pierdut peste 5.8 miliarde de dolari din cauza fraudelor în 2021, în creștere cu peste 70% față de 2020. Multe tehnici au fost folosite pentru a detecta fraudatorii - filtre bazate pe reguli, detectarea anomaliilor și modele de învățare automată (ML), pentru a numi câteva.

În datele din lumea reală, entitățile implică adesea relații bogate cu alte entități. O astfel de structură grafică poate oferi informații valoroase pentru detectarea anomaliilor. De exemplu, în figura următoare, utilizatorii sunt conectați prin entități partajate, cum ar fi ID-uri Wi-Fi, locații fizice și numere de telefon. Datorită numărului mare de valori unice ale acestor entități, cum ar fi numerele de telefon, este dificil să le folosești în modelele tradiționale bazate pe caracteristici — de exemplu, codificarea unică a tuturor numerelor de telefon nu ar fi viabilă. Dar astfel de relații ar putea ajuta la prezicerea dacă un utilizator este un fraudator. Dacă un utilizator a partajat mai multe entități cu un fraudator cunoscut, utilizatorul este mai probabil un fraudator.

Recent, rețeaua neuronală grafică (GNN) a devenit o metodă populară pentru detectarea fraudelor. Modelele GNN pot combina atât structura grafică, cât și atributele nodurilor sau marginilor, cum ar fi utilizatorii sau tranzacțiile, pentru a învăța reprezentări semnificative pentru a distinge utilizatorii și evenimentele rău intenționate de cele legitime. Această capacitate este crucială pentru detectarea fraudelor în care fraudatorii se complică pentru a-și ascunde caracteristicile anormale, dar lasă câteva urme de relații.

Soluțiile actuale GNN se bazează în principal pe formarea offline pe lot și pe modul de inferență, care detectează fraudatorii după ce au avut loc evenimente rău intenționate și au avut loc pierderi. Cu toate acestea, capturarea utilizatorilor și activităților frauduloase în timp real este crucială pentru prevenirea pierderilor. Acest lucru este valabil mai ales în cazurile de afaceri în care există o singură șansă de a preveni activitățile frauduloase. De exemplu, în unele platforme de comerț electronic, înregistrarea contului este larg deschisă. Escrocii pot avea un comportament rău intenționat doar o singură dată cu un cont și nu pot mai folosi niciodată același cont.

Este important să preziceți fraudatorii în timp real. Construirea unei astfel de soluții este însă o provocare. Deoarece GNN-urile sunt încă noi în industrie, există resurse online limitate pentru conversia modelelor GNN de la difuzarea în lot la difuzarea în timp real. În plus, este o provocare să construiești o conductă de date în flux care poate alimenta evenimentele primite către un API de servire în timp real GNN. După cunoștințele autorilor, nu sunt disponibile arhitecturi de referință și exemple pentru soluții de inferență în timp real bazate pe GNN la momentul scrierii acestui articol.

Pentru a ajuta dezvoltatorii să aplice GNN-urile pentru detectarea fraudelor în timp real, această postare arată cum se utilizează Amazon Neptun, Amazon SageMaker, Şi Biblioteca Deep Graph (DGL), printre alte servicii AWS, pentru a construi o soluție end-to-end pentru detectarea fraudelor în timp real folosind modele GNN.

Ne concentrăm pe patru sarcini:

• Procesarea unui set de date de tranzacție tabelar într-un set de date grafic eterogen
• Antrenarea unui model GNN folosind SageMaker
• Implementarea modelelor GNN instruite ca punct final SageMaker
• Demonstrarea inferenței în timp real pentru tranzacțiile primite

Această postare extinde munca anterioară în Detectarea fraudei în rețele eterogene folosind Amazon SageMaker și Deep Graph Library, care se concentrează pe primele două sarcini. Puteți consulta acea postare pentru mai multe detalii despre graficele eterogene, GNN-uri și antrenamentul semi-supravegheat al GNN-urilor.

Companiile care caută un serviciu AWS AI complet gestionat pentru detectarea fraudelor pot folosi și ele Detector de fraude Amazon, ceea ce facilitează identificarea activităților online potențial frauduloase, cum ar fi crearea de conturi false sau frauda de plată online.

Prezentare generală a soluțiilor

Această soluție conține două părți majore.

Prima parte este o conductă care procesează datele, antrenează modele GNN și implementează modelele antrenate. Folosește AWS Adeziv pentru a procesa datele tranzacției și salvează datele procesate în ambele Amazon Neptun și Serviciul Amazon de stocare simplă (Amazon S3). Apoi, este declanșată un job de instruire SageMaker pentru a antrena un model GNN pe datele salvate în Amazon S3 pentru a prezice dacă o tranzacție este frauduloasă. Modelul instruit împreună cu alte active sunt salvate înapoi pe Amazon S3 la finalizarea sarcinii de instruire. În cele din urmă, modelul salvat este implementat ca punct final SageMaker. Conducta este orchestrată de Funcții pas AWS, așa cum se arată în figura următoare.

A doua parte a soluției implementează detectarea tranzacțiilor frauduloase în timp real. Pornește de la un API RESTful care interogează baza de date cu grafice din Neptune pentru a extrage subgraful legat de o tranzacție primită. De asemenea, are un portal web care poate simula activități de afaceri, generând tranzacții online atât cu cele frauduloase, cât și cu cele legitime. Portalul web oferă o vizualizare live a detectării fraudei. Această parte folosește Amazon CloudFront, Amplificare AWS, AWS AppSync, Gateway API Amazon, Funcții pas și Amazon DocumentDB pentru a construi rapid aplicația web. Următoarea diagramă ilustrează procesul de inferență în timp real și portalul web.

Implementarea acestei soluții, împreună cu un Formarea AWS Cloud șablonul care poate lansa arhitectura în contul dvs. AWS, este disponibil public prin următoarele GitHub repo.

Procesarea datelor

În această secțiune, descriem pe scurt cum să procesăm un exemplu de set de date și să îl convertim din tabele brute într-un grafic cu relații identificate între diferite coloane.

Această soluție folosește același set de date, the Setul de date privind fraudele IEEE-CIS, ca postarea anterioară Detectarea fraudei în rețele eterogene folosind Amazon SageMaker și Deep Graph Library. Prin urmare, principiul de bază al procesului de date este același. Pe scurt, setul de date privind fraudele include un tabel de tranzacții și un tabel de identități, având aproape 500,000 de înregistrări anonime ale tranzacțiilor împreună cu informații contextuale (de exemplu, dispozitivele utilizate în tranzacții). Unele tranzacții au o etichetă binară, care indică dacă o tranzacție este frauduloasă. Sarcina noastră este să anticipăm care tranzacții fără etichetă sunt frauduloase și care sunt legitime.

Următoarea figură ilustrează procesul general de conversie a tabelelor IEEE într-un grafic eterogen. Mai întâi extragem două coloane din fiecare tabel. O coloană este întotdeauna coloana ID tranzacție, unde setăm fiecare TransactionID unic ca un singur nod. O altă coloană este aleasă din coloanele categorice, cum ar fi coloanele ProductCD și id_03, unde fiecare categorie unică a fost setată ca nod. Dacă un TransactionID și o categorie unică apar pe același rând, le conectăm cu o singură margine. În acest fel, convertim două coloane dintr-un tabel într-un singur bipartit. Apoi combinăm acele bipartiți împreună cu nodurile TransactionID, unde aceleași noduri TransactionID sunt îmbinate într-un singur nod unic. După acest pas, avem un grafic eterogen construit din bipartiți.

Pentru restul coloanelor care nu sunt folosite pentru a construi graficul, le unim împreună ca caracteristică a nodurilor TransactionID. Valorile TransactionID care au valorile isFraud sunt folosite ca etichetă pentru formarea modelului. Pe baza acestui grafic eterogen, sarcina noastră devine o sarcină de clasificare a nodurilor a nodurilor TransactionID. Pentru mai multe detalii despre pregătirea datelor graficului pentru antrenarea GNN-urilor, consultați Extragerea caracteristicilor și Construirea graficului secțiunile postării anterioare de pe blog.

Codul folosit în această soluție este disponibil în src/scripts/glue-etl.py. De asemenea, puteți experimenta procesarea datelor prin notebook-ul Jupyter src/sagemaker/01.FD_SL_Process_IEEE-CIS_Dataset.ipynb.

În loc să proceseze manual datele, așa cum s-a făcut în postarea anterioară, această soluție folosește o conductă complet automată orchestrată de Step Functions și AWS Glue, care acceptă procesarea de seturi de date uriașe în paralel prin Apache Spark. Fluxul de lucru Step Functions este scris Kit AWS Cloud Development (AWS CDK). Următorul este a fragment de cod pentru a crea acest flux de lucru:

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

Pe lângă construirea datelor graficului pentru antrenamentul modelului GNN, acest flux de lucru încarcă, de asemenea, în lot datele graficului în Neptune pentru a efectua inferențe în timp real mai târziu. Acest proces de încărcare a datelor în lot este demonstrat în următorul fragment de cod:

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

Antrenament model GNN

După ce datele graficului pentru antrenamentul modelului sunt salvate în Amazon S3, a Job de formare SageMaker, care este încărcat numai atunci când lucrarea de instruire rulează, este declanșată pentru a începe procesul de formare a modelului GNN în modul Bring Your Own Container (BYOC). Vă permite să împachetați scripturile și dependențele de antrenament ale modelului într-o imagine Docker, pe care o folosește pentru a crea instanțe de antrenament SageMaker. Metoda BYOC ar putea economisi efort semnificativ în configurarea mediului de antrenament. În src/sagemaker/02.FD_SL_Build_Training_Container_Test_Local.ipynb, puteți găsi detalii despre antrenamentul modelului GNN.

Imagine Docker

Prima parte a fișierului blocnotes Jupyter este generarea de imagini Docker de antrenament (consultați următorul fragment de cod):

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

Am folosit o imagine bazată pe PyTorch pentru antrenamentul modelului. Biblioteca Deep Graph (DGL) și alte dependențe sunt instalate la construirea imaginii Docker. Codul modelului GNN în src/sagemaker/FD_SL_DGL/gnn_fraud_detection_dgl folderul este copiat și în imagine.

Deoarece procesăm datele tranzacției într-un grafic eterogen, în această soluție alegem Rețeaua convoluțională a graficului relațional (RGCN), care este conceput special pentru grafice eterogene. Modelul nostru RGCN poate antrena înglobări care pot fi învățate pentru noduri în grafice eterogene. Apoi, înglobările învățate sunt utilizate ca intrări ale unui strat complet conectat pentru prezicerea etichetelor nodurilor.

Hiperparametrele

Pentru a antrena GNN, trebuie să definim câțiva hiperparametri înainte de procesul de antrenament, cum ar fi numele de fișiere ale graficului construit, numărul de straturi ale modelelor GNN, epocile de antrenament, optimizatorul, parametrii de optimizare și multe altele. Consultați următorul cod pentru un subset de configurații:

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}

Pentru mai multe informații despre toți hiperparametrii și valorile lor implicite, consultați estimator_fns.py în src/sagemaker/FD_SL_DGL/gnn_fraud_detection_dgl dosar.

Antrenament model cu SageMaker

După ce imaginea personalizată a containerului Docker este construită, folosim datele preprocesate pentru a antrena modelul nostru GNN cu hiperparametrii definiți. Jobul de instruire folosește DGL, cu PyTorch ca cadru de învățare profundă backend, pentru a construi și a antrena GNN. SageMaker facilitează antrenarea modelelor GNN cu imaginea Docker personalizată, care este un argument de intrare al estimatorului SageMaker. Pentru mai multe informații despre formarea GNN-urilor cu DGL pe SageMaker, consultați Antrenați o rețea Deep Graph.

Folosește SDK-ul SageMaker Python Estimator pentru a îngloba antrenamentul pe SageMaker, care rulează containere Docker personalizate compatibile cu SageMaker, permițându-vă să rulați propriii algoritmi ML folosind SDK-ul SageMaker Python. Următorul fragment de cod demonstrează antrenarea modelului cu SageMaker (fie într-un mediu local, fie în instanțe 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)

După antrenament, performanța modelului GNN pe setul de testare este afișată ca următoarele ieșiri. În mod normal, modelul RGCN poate atinge aproximativ 0.87 AUC și o precizie mai mare de 95%. Pentru o comparație a modelului RGCN cu alte modele ML, consultați REZULTATE secțiunea postării anterioare de blog pentru mai multe detalii.

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

După finalizarea instruirii modelului, SageMaker împachetează modelul antrenat împreună cu alte active, inclusiv încorporarea nodurilor antrenate, într-un fișier ZIP și apoi îl încarcă într-o locație S3 specificată. În continuare, discutăm despre implementarea modelului antrenat pentru detectarea frauduloasă în timp real.

Implementarea modelului GNN

SageMaker simplifică implementarea modelelor ML instruite. În această etapă, folosim clasa SageMaker PyTorchModel pentru a implementa modelul antrenat, deoarece modelul nostru DGL depinde de PyTorch ca cadru backend. Puteți găsi codul de implementare în src/sagemaker/03.FD_SL_Endpoint_Deployment.ipynb fișier.

Pe lângă fișierul model antrenat și active, SageMaker necesită un fișier punct de intrare pentru implementarea unui model personalizat. Fișierul punctului de intrare este rulat și stocat în memoria unei instanțe de punct final de inferență pentru a răspunde la cererea de inferență. În cazul nostru, fișierul punct de intrare este fd_sl_deployment_entry_point.py de fișier în src/sagemaker/FD_SL_DGL/code folder, care îndeplinește patru funcții majore:

• Primiți solicitări și analizați conținutul cererilor pentru a obține nodurile care urmează să fie prezise și datele asociate acestora
• Convertiți datele într-un grafic eterogen DGL ca intrare pentru modelul RGCN
• Efectuați inferența în timp real prin modelul RGCN antrenat
• Returnează rezultatele predicției solicitantului

Urmând convențiile SageMaker, primele două funcții sunt implementate în input_fn metodă. Vedeți următorul cod (pentru simplitate, ștergem un cod de comentariu):

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)

Graficul și caracteristicile DGL construite sunt apoi transmise la predict_fn metoda de a indeplini a treia functie. predict_fn ia două argumente de intrare: ieșirile ale input_fn și modelul antrenat. Vezi următorul cod:

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]

Modelul folosit în perdict_fn este creat de către model_fn metoda când punctul final este apelat prima dată. Functia model_fn încarcă fișierul model salvat și activele asociate din model_dir argument și folderul model SageMaker. Vezi următorul cod:

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

Ieșirea fișierului predict_fn metoda este o listă de două numere, indicând logit-urile pentru clasa 0 și clasa 1, unde 0 înseamnă legitim și 1 înseamnă fraudulos. SageMaker ia această listă și o transmite unei metode interioare numite output_fn pentru a finaliza funcția finală.

Pentru a implementa modelul nostru GNN, mai întâi împachetăm modelul GNN într-o clasă SageMaker PyTorchModel cu fișierul punct de intrare și alți parametri (calea fișierului ZIP salvat, versiunea cadru PyTorch, versiunea Python și așa mai departe). Apoi îi numim metoda de implementare cu setări de instanță. Vezi următorul cod:

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

Procedurile și fragmentele de cod anterioare demonstrează cum să implementați modelul dvs. GNN ca punct final de inferență online dintr-un notebook Jupyter. Cu toate acestea, pentru producție, vă recomandăm să utilizați conducta MLOps menționată anterior, orchestrată de Step Functions pentru întregul flux de lucru, inclusiv procesarea datelor, instruirea modelului și implementarea unui punct final de inferență. Întreaga conductă este implementată de un AWS CDK cerere, care poate fi reprodus cu ușurință în diferite regiuni și conturi.

Inferință în timp real

Când sosește o nouă tranzacție, pentru a efectua predicții în timp real, trebuie să parcurgem patru pași:

1. Inserarea nodului și marginii – Extrageți informațiile tranzacției, cum ar fi ID-ul tranzacției și CD-ul de produs ca noduri și margini și inserați noile noduri în datele grafice existente stocate în baza de date Neptune.
2. Extragerea subgrafului – Setați nodul de tranzacție care urmează să fie prezis ca nod central și extrageți un subgraf n-hop conform cerințelor de intrare ale modelului GNN.
3. Extragerea caracteristicilor – Pentru nodurile și marginile din subgraf, extrageți caracteristicile asociate acestora.
4. Apelați punctul final de inferență – Împachetați subgraful și caracteristicile în conținutul unei cereri, apoi trimiteți solicitarea la punctul final de inferență.

În această soluție, implementăm un API RESTful pentru a obține predicția frauduloasă în timp real descrisă în pașii precedenți. Consultați următorul pseudo-cod pentru predicții în timp real. Implementarea completă este în fișierul complet cu codul sursă.

Pentru predicție în timp real, primii trei pași necesită o latență mai mică. Prin urmare, o bază de date cu grafice este o alegere optimă pentru aceste sarcini, în special pentru extragerea subgrafelor, care ar putea fi realizată eficient cu interogări de baze de date grafice. Funcțiile de subliniere care acceptă pseudo-codul se bazează pe interogările gremlin ale lui 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 avertisment despre detectarea fraudelor în timp real folosind GNN-uri este modul de inferență GNN. Pentru a îndeplini inferența în timp real, trebuie să convertim inferența modelului GNN din modul transductiv în modul inductiv. Modelele GNN în modul de inferență transductivă nu pot face predicții pentru nodurile și marginile nou apărute, în timp ce în modul inductiv, modelele GNN pot gestiona noduri și margini noi. O demonstrație a diferenței dintre modul transductiv și inductiv este prezentată în figura următoare.

În modul transductiv, nodurile și marginile prezise coexistă cu nodurile și marginile etichetate în timpul antrenamentului. Modelele le identifică înainte de inferență și ar putea fi deduse în timpul antrenamentului. Modelele în modul inductiv sunt antrenate pe graficul de antrenament, dar trebuie să prezică nodurile nevăzute (cele din cercuri punctate roșii din dreapta) cu vecinii lor asociați, care ar putea fi noduri noi, cum ar fi nodul triunghi gri din dreapta.

Modelul nostru RGCN este antrenat și testat în modul transductiv. Are acces la toate nodurile aflate în formare și, de asemenea, a antrenat o încorporare pentru fiecare nod fără caracteristici, cum ar fi adresa IP și tipurile de carduri. În etapa de testare, modelul RGCN utilizează aceste înglobări ca caracteristici de nod pentru a prezice nodurile din setul de testare. Când facem inferențe în timp real, totuși, unele dintre nodurile fără caracteristici nou adăugate nu au astfel de încorporare, deoarece nu sunt în graficul de antrenament. O modalitate de a rezolva această problemă este să atribuiți noilor noduri media tuturor înglobărilor din același tip de nod. În această soluție, adoptăm această metodă.

În plus, această soluție oferă un portal web (după cum se vede în următoarea captură de ecran) pentru a demonstra predicțiile frauduloase în timp real din perspectiva operatorilor de afaceri. Poate genera tranzacții online simulate și poate oferi o vizualizare live a informațiilor despre tranzacțiile frauduloase detectate.

A curăța

Când ai terminat de explorat soluția, poți curata resursele pentru a evita suportarea taxelor.

Concluzie

În această postare, am arătat cum să construim o soluție de detectare a fraudei în timp real bazată pe GNN folosind SageMaker, Neptune și DGL. Această soluție are trei avantaje majore:

• Are performanțe bune în ceea ce privește acuratețea predicției și metrica AUC
• Poate efectua inferențe în timp real prin intermediul unei conducte MLOps în flux și punctelor finale SageMaker
• Automatizează procesul total de implementare cu șablonul CloudFormation furnizat, astfel încât dezvoltatorii interesați să poată testa cu ușurință această soluție cu date personalizate în contul lor

Pentru mai multe detalii despre soluție, consultați GitHub repo.

După ce implementați această soluție, vă recomandăm să personalizați codul de procesare a datelor pentru a se potrivi propriului format de date și să modificați mecanismul de inferență în timp real, păstrând în același timp modelul GNN neschimbat. Rețineți că am împărțit inferența în timp real în patru pași, fără o optimizare suplimentară a latenței. Acești patru pași durează câteva secunde pentru a obține o predicție asupra setului de date demonstrative. Credem că optimizarea designului schemei de date a graficului Neptune și a interogărilor pentru extragerea subgrafului și a caracteristicilor poate reduce semnificativ latența de inferență.

Despre autori

Jian Zhang este un om de știință aplicat care a folosit tehnici de învățare automată pentru a ajuta clienții să rezolve diverse probleme, cum ar fi detectarea fraudelor, generarea de imagini decorative și multe altele. El a dezvoltat cu succes învățarea automată bazată pe grafice, în special rețele neuronale grafice, soluții pentru clienți din China, SUA și Singapore. Ca un iluminator al capabilităților grafice ale AWS, Zhang a susținut multe prezentări publice despre GNN, Deep Graph Library (DGL), Amazon Neptune și alte servicii AWS.

Mengxin Zhu este manager al Arhitecților de soluții la AWS, cu accent pe proiectarea și dezvoltarea de soluții AWS reutilizabile. El este implicat în dezvoltarea de software de mulți ani și a fost responsabil pentru mai multe echipe de startup de diferite dimensiuni. El este, de asemenea, un susținător al software-ului open-source și a fost Eclipse Committer.

Haozhu Wang este cercetător la Amazon ML Solutions Lab, unde co-conduce Reinforcement Learning Vertical. El ajută clienții să construiască soluții avansate de învățare automată cu cele mai recente cercetări privind învățarea graficelor, procesarea limbajului natural, învățarea prin consolidare și AutoML. Haozhu și-a luat doctoratul în Inginerie Electrică și Calculatoare de la Universitatea din Michigan.