Looge GNN-põhine reaalajas pettuste tuvastamise lahendus Amazon SageMakeri, Amazon Neptune'i ja Deep Graph Library abil

Pettused mõjutavad tõsiselt paljusid tööstusharusid, nagu e-kaubandus, sotsiaalmeedia ja finantsteenused. Pettused võivad ettevõtetele ja tarbijatele põhjustada märkimisväärset kahju. Ameerika tarbijad teatasid, et kaotasid 5.8. aastal pettuste tõttu rohkem kui 2021 miljardit dollarit, mis on rohkem kui 70% rohkem kui 2020. aastal. Petturite tuvastamiseks on kasutatud paljusid tehnikaid – reeglipõhiseid filtreid, anomaaliate tuvastamist ja masinõppe (ML) mudeleid.

Reaalmaailma andmetes hõlmavad olemid sageli rikkalikke suhteid teiste üksustega. Selline graafiku struktuur võib anda väärtuslikku teavet anomaalia tuvastamiseks. Näiteks järgmisel joonisel on kasutajad ühendatud jagatud üksuste kaudu, nagu Wi-Fi ID-d, füüsilised asukohad ja telefoninumbrid. Nende olemite unikaalsete väärtuste (nt telefoninumbrid) suure hulga tõttu on nende kasutamine traditsioonilistes funktsioonipõhistes mudelites keeruline – näiteks ei oleks kõigi telefoninumbrite ühekordne kodeerimine otstarbekas. Kuid sellised suhted võivad aidata ennustada, kas kasutaja on pettur. Kui kasutaja on jaganud mitut olemit tuntud petturiga, on kasutaja tõenäoliselt pettur.

Hiljuti on graafiline närvivõrk (GNN) muutunud populaarseks meetodiks pettuste tuvastamiseks. GNN-i mudelid võivad kombineerida nii graafiku struktuuri kui ka sõlmede või servade atribuute (nt kasutajad või tehingud), et õppida tähenduslikke esitusi, et eristada pahatahtlikke kasutajaid ja sündmusi seaduslikest. See võimalus on ülioluline selliste pettuste tuvastamisel, kus petturid teevad kokkumängu, et varjata oma ebanormaalseid jooni, kuid jätavad jälje suhetest.

Praegused GNN-i lahendused toetuvad peamiselt võrguühenduseta partiiõppele ja järeldusrežiimile, mis tuvastavad petturid pärast pahatahtlike sündmuste toimumist ja kahjude tekkimist. Petturlike kasutajate ja tegevuste reaalajas tabamine on aga kahjude ärahoidmiseks ülioluline. See kehtib eriti ärijuhtumite puhul, kus on ainult üks võimalus pettust ära hoida. Näiteks mõnel e-kaubanduse platvormil on konto registreerimine laialt avatud. Petturid võivad kontoga pahatahtlikult käituda vaid korra ega kasuta sama kontot enam kunagi.

Petturite reaalajas ennustamine on oluline. Sellise lahenduse loomine on aga keeruline. Kuna GNN-id on selles valdkonnas veel uued, on GNN-i mudelite partiipõhisest serveerimisest reaalajas esitamiseks teisendamiseks piiratud võrguressursse. Lisaks on keeruline luua voogesituse andmekonveier, mis suudab edastada sissetulevad sündmused GNN-i reaalajas teenindavale API-le. Autorite teadmiste kohaselt ei ole selle kirjutamise seisuga GNN-põhiste reaalajas järelduslahenduste jaoks saadaval ühtegi viitearhitektuuri ja -näiteid.

See postitus näitab, kuidas kasutada GNN-e reaalajas pettuste tuvastamiseks, et aidata arendajatel neid kasutada Amazon Neptuun, Amazon SageMakerJa Deep Graph Library (DGL), et koos teiste AWS-teenustega luua täielik lahendus reaalajas pettuste tuvastamiseks, kasutades GNN-i mudeleid.

Keskendume neljale ülesandele:

• Tabelikujulise tehinguandmestiku töötlemine heterogeenseks graafiku andmestikuks
• GNN-mudeli koolitamine SageMakeri abil
• Koolitatud GNN-mudelite juurutamine SageMakeri lõpp-punktina
• Sissetulevate tehingute reaalajas järelduste näitamine

See postitus pikendab varasemat tööd Pettuste tuvastamine heterogeensetes võrkudes Amazon SageMakeri ja Deep Graph Library abil, mis keskendub kahele esimesele ülesandele. Lisateavet heterogeensete graafikute, GNN-ide ja GNN-ide pooljärelevalvega koolituse kohta leiate sellest postitusest.

Seda saavad kasutada ka ettevõtted, kes otsivad pettuste tuvastamiseks täielikult hallatud AWS AI teenust Amazoni pettusedetektor, mille abil on lihtne tuvastada potentsiaalselt petturlikke võrgutegevusi, nagu võltskontode loomine või võrgumaksepettus.

Lahenduse ülevaade

See lahendus sisaldab kahte põhiosa.

Esimene osa on torujuhe, mis töötleb andmeid, koolitab GNN-mudeleid ja juurutab koolitatud mudeleid. See kasutab AWS liim tehinguandmete töötlemiseks ja salvestab töödeldud andmed mõlemasse Amazon Neptuun ja Amazoni lihtne salvestusteenus (Amazon S3). Seejärel käivitatakse SageMakeri koolitustöö, et koolitada GNN-i mudelit Amazon S3 salvestatud andmete põhjal, et ennustada, kas tehing on petturlik. Koolitatud mudel koos muude varadega salvestatakse pärast koolitustöö lõpetamist Amazon S3-sse. Lõpuks juurutatakse salvestatud mudel SageMakeri lõpp-punktina. Torujuhtme orkestreerib AWS-i astmefunktsioonid, nagu on näidatud järgmisel joonisel.

Lahenduse teine ​​osa rakendab reaalajas pettustehingute tuvastamist. See algab RESTful API-st, mis teeb päringu Neptune'i graafikute andmebaasist, et eraldada sissetuleva tehinguga seotud alamgraaf. Sellel on ka veebiportaal, mis võib simuleerida äritegevust, genereerides veebitehinguid nii petturlike kui ka seaduslike tehingutega. Veebiportaal pakub pettuse tuvastamise reaalajas visualiseerimist. See osa kasutab Amazon CloudFront, AWS võimendus, AWS AppSync, Amazon API värav, Sammufunktsioonid ja Amazon DocumentDB veebirakenduse kiireks loomiseks. Järgmine diagramm illustreerib reaalajas järeldusprotsessi ja veebiportaali.

Selle lahenduse rakendamine koos an AWS CloudFormation mall, mis võib teie AWS-i konto arhitektuuri käivitada, on avalikult saadaval järgmise kaudu GitHub repo.

Andmetöötlus

Selles jaotises kirjeldame lühidalt, kuidas töödelda näidisandmestikku ja teisendada see töötlemata tabelitest graafikuks, mille seosed on tuvastatud erinevate veergude vahel.

See lahendus kasutab sama andmestikku, IEEE-CIS pettuste andmestik, nagu eelmine postitus Pettuste tuvastamine heterogeensetes võrkudes Amazon SageMakeri ja Deep Graph Library abil. Seetõttu on andmetöötluse aluspõhimõte sama. Lühidalt, pettuste andmestik sisaldab tehingute tabelit ja identiteedi tabelit, milles on peaaegu 500,000 XNUMX anonüümseks muudetud tehingukirjet koos kontekstuaalse teabega (näiteks tehingutes kasutatavad seadmed). Mõnel tehingul on binaarne silt, mis näitab, kas tehing on petturlik. Meie ülesanne on ennustada, millised märgistamata tehingud on petturlikud ja millised legitiimsed.

Järgmine joonis illustreerib üldist protsessi IEEE tabelite heterogeenseks graafikuks teisendamiseks. Esmalt eraldame igast tabelist kaks veergu. Üks veerg on alati tehingu ID veerg, kus seame iga kordumatu tehingu ID üheks sõlmeks. Kategoorilistest veergudest (nt ProductCD ja id_03) valitakse veel üks veerg, kus iga kordumatu kategooria määrati sõlmeks. Kui tehingu ID ja kordumatu kategooria ilmuvad samal real, ühendame need ühe servaga. Nii teisendame tabeli kaks veergu üheks kahepoolseks. Seejärel ühendame need kaheosalised koos TransactionID sõlmedega, kus samad TransactionID sõlmed liidetakse üheks unikaalseks sõlmeks. Pärast seda sammu on meil heterogeenne graaf, mis on ehitatud kaheosalistest osadest.

Ülejäänud veergude puhul, mida graafiku koostamiseks ei kasutata, ühendame need TransactionID sõlmede funktsioonina. TransactionID väärtusi, millel on isFraud väärtused, kasutatakse mudelikoolituse sildina. Selle heterogeense graafiku põhjal saab meie ülesandest TransactionID sõlmede sõlmede klassifitseerimise ülesanne. Lisateavet graafiku andmete ettevalmistamise kohta GNN-ide treenimiseks vaadake jaotisest Funktsiooni eraldamine ja Graafiku koostamine eelmise blogipostituse lõigud.

Selles lahenduses kasutatav kood on saadaval keeles src/scripts/glue-etl.py. Andmetöötlust saate katsetada ka Jupyteri sülearvuti kaudu src/sagemaker/01.FD_SL_Process_IEEE-CIS_Dataset.ipynb.

Selle asemel, et andmeid käsitsi töödelda, nagu tehti eelmises postituses, kasutab see lahendus Step Functionsi ja AWS Glue'i korraldatud täisautomaatset konveieri, mis toetab tohutute andmekogumite paralleelset töötlemist Apache Sparki kaudu. Step Functions töövoog on sisse kirjutatud AWS pilvearenduskomplekt (AWS CDK). Järgmine on a koodijupp selle töövoo loomiseks tehke järgmist.

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

Lisaks graafikuandmete koostamisele GNN-i mudeli koolituse jaoks laadib see töövoog graafiku andmed ka Neptune'i, et teha hiljem reaalajas järeldusi. See pakettandmete laadimise protsess on näidatud järgmises koodijupis:

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 mudeli koolitus

Pärast mudelitreeningu graafikuandmete salvestamist Amazon S3-sse, a SageMakeri koolitustöö, mida võetakse tasu ainult siis, kui treeningtöö on käimas, käivitatakse GNN-mudeli koolitusprotsessi käivitamiseks režiimis Bring Your Own Container (BYOC). See võimaldab teil pakkida mudeli koolitusskriptid ja sõltuvused Dockeri kujutisele, mida see kasutab SageMakeri koolituseksemplaride loomiseks. BYOC-meetod võib säästa märkimisväärseid jõupingutusi koolituskeskkonna seadistamisel. sisse src/sagemaker/02.FD_SL_Build_Training_Container_Test_Local.ipynb, leiate üksikasjad GNN-i mudelikoolituse kohta.

Dockeri pilt

Jupyteri sülearvuti faili esimene osa on Dockeri pildi loomine (vt järgmist koodilõiku):

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

Mudelitreeningu jaoks kasutasime PyTorchi-põhist pilti. Dockeri kujutise loomisel installitakse Deep Graph Library (DGL) ja muud sõltuvused. GNN-i mudeli kood src/sagemaker/FD_SL_DGL/gnn_fraud_detection_dgl kaust kopeeritakse ka pildile.

Kuna töötleme tehinguandmeid heterogeenseks graafikuks, valime selles lahenduses Relatsioonigraafiku konvolutsioonivõrk (RGCN) mudel, mis on spetsiaalselt loodud heterogeensete graafikute jaoks. Meie RGCN-mudel saab treenida heterogeensete graafikute sõlmede jaoks õpitavaid manuseid. Seejärel kasutatakse õpitud manuseid täielikult ühendatud kihi sisenditena sõlme siltide ennustamiseks.

Hüperparameetrid

GNN-i koolitamiseks peame enne koolitusprotsessi määratlema mõned hüperparameetrid, näiteks konstrueeritud graafiku failinimed, GNN-i mudelite kihtide arv, koolitusperioodid, optimeerija, optimeerimisparameetrid ja palju muud. Konfiguratsioonide alamhulga kohta vaadake järgmist koodi:

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}

Kõigi hüperparameetrite ja nende vaikeväärtuste kohta lisateabe saamiseks vt estimator_fns.py aasta src/sagemaker/FD_SL_DGL/gnn_fraud_detection_dgl kausta.

Mudelitreening SageMakeriga

Pärast kohandatud konteineri Dockeri kujutise loomist kasutame eeltöödeldud andmeid, et koolitada oma GNN-mudelit meie määratletud hüperparameetritega. Koolitustöö kasutab GNN-i ehitamiseks ja koolitamiseks DGL-i, mille taustaks on süvaõpperaamistik PyTorch. SageMaker muudab GNN-i mudelite treenimise lihtsaks kohandatud Dockeri kujutisega, mis on SageMakeri hindaja sisendargument. Lisateavet GNN-ide treenimise kohta SageMakeris DGL-iga vt Treenige Deep Graph võrku.

Kasutab SageMaker Python SDK Hindaja kapseldada koolitust SageMakeriga, mis käitab SageMakeriga ühilduvaid kohandatud Dockeri konteinereid, mis võimaldab teil käitada oma ML-algoritme, kasutades SageMaker Python SDK-d. Järgmine koodilõik demonstreerib mudeli SageMakeriga treenimist (kas kohalikus keskkonnas või pilve eksemplarides):

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)

Pärast treenimist kuvatakse GNN-i mudeli jõudlus testkomplektis nagu järgmised väljundid. RGCN-mudel võib tavaliselt saavutada umbes 0.87 AUC ja rohkem kui 95% täpsust. RGCN-mudeli võrdlemiseks teiste ML-mudelitega vaadake jaotist Tulemused Lisateabe saamiseks eelmise blogipostituse jaotises.

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

Pärast mudelikoolituse lõpetamist pakib SageMaker koolitatud mudeli koos muude varadega, sealhulgas koolitatud sõlmede manustega, ZIP-faili ja laadib selle seejärel üles määratud S3 asukohta. Järgmisena arutame koolitatud mudeli kasutuselevõttu reaalajas pettuste tuvastamiseks.

GNN-i mudeli juurutamine

SageMaker muudab koolitatud ML-mudelite juurutamise lihtsaks. Selles etapis kasutame koolitatud mudeli juurutamiseks klassi SageMaker PyTorchModel, kuna meie DGL-mudel sõltub PyTorchist kui taustaraamistikust. Juurutuskoodi leiate aadressilt src/sagemaker/03.FD_SL_Endpoint_Deployment.ipynb faili.

Lisaks koolitatud mudelifailile ja varadele vajab SageMaker kohandatud mudeli juurutamiseks sisestuspunkti faili. Sisendpunkti faili käivitatakse ja see salvestatakse järelduse lõpp-punkti eksemplari mällu, et vastata järelduspäringule. Meie puhul on sisestuspunkti fail fd_sl_deployment_entry_point.py failil src/sagemaker/FD_SL_DGL/code kaust, mis täidab nelja peamist funktsiooni:

• Prognoositavate sõlmede ja nendega seotud andmete hankimiseks võtke vastu taotlusi ja sõeluge päringute sisu
• Teisendage andmed RGCN-mudeli sisendiks DGL-i heterogeenseks graafikuks
• Tehke reaalajas järeldus koolitatud RGCN-mudeli kaudu
• Tagastage ennustuse tulemused taotlejale

Järgides SageMakeri tavasid, on kaks esimest funktsiooni rakendatud input_fn meetod. Vaadake järgmist koodi (lihtsuse huvides kustutame mõne kommentaarikoodi):

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)

Seejärel edastatakse koostatud DGL-i graafik ja funktsioonid predict_fn meetod kolmanda funktsiooni täitmiseks. predict_fn võtab kaks sisendargumenti: väljundid input_fn ja koolitatud modell. Vaadake järgmist koodi:

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]

aastal kasutatud mudel perdict_fn on loodud model_fn meetodit, kui lõpp-punkti kutsutakse esimest korda. Funktsioon model_fn laadib failist salvestatud mudelifaili ja sellega seotud varad model_dir argument ja SageMakeri mudelikaust. Vaadake järgmist koodi:

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

Väljund predict_fn meetod on kahest numbrist koosnev loend, mis näitab klassi 0 ja klassi 1 logiteid, kus 0 tähendab seaduslikku ja 1 tähendab pettust. SageMaker võtab selle loendi ja edastab selle sisemisele meetodile nimega output_fn lõpliku funktsiooni lõpuleviimiseks.

GNN-i mudeli juurutamiseks mässime GNN-i mudeli esmalt SageMakeri PyTorchModel-klassi koos sisestuspunkti faili ja muude parameetritega (salvestatud ZIP-faili tee, PyTorchi raamistiku versioon, Pythoni versioon jne). Seejärel kutsume selle juurutusmeetodiks eksemplari sätetega. Vaadake järgmist koodi:

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

Eelnevad protseduurid ja koodilõigud näitavad, kuidas juurutada oma GNN-mudelit Jupyteri sülearvutist veebipõhise järelduse lõpp-punktina. Tootmise jaoks soovitame aga kasutada kogu töövoo jaoks eelnevalt mainitud MLOps-konveieri, mis on organiseeritud Step Functionsiga, sealhulgas andmete töötlemiseks, mudeli treenimiseks ja järeldusotsa juurutamiseks. Kogu torujuhtme rakendab AWS CDK taotlus, mida saab hõlpsasti kopeerida erinevates piirkondades ja kontodel.

Reaalajas järeldus

Kui uus tehing saabub, peame reaalajas ennustamiseks tegema neli sammu:

1. Sõlme ja serva sisestamine – Ekstraktige tehinguteave (nt TransactionID ja ProductCD) sõlmede ja servadena ning sisestage uued sõlmed olemasolevatesse Neptune'i andmebaasi salvestatud graafikuandmetesse.
2. Alamgraafi ekstraheerimine – Määrake prognoositav tehingusõlm kesksõlmeks ja ekstraheerige n-hüppe alamgraaf vastavalt GNN-i mudeli sisendnõuetele.
3. Funktsiooni eraldamine – Alamgraafi sõlmede ja servade jaoks eraldage nendega seotud omadused.
4. Kutsuge järelduse lõpp-punkt – Pakkige alamgraaf ja funktsioonid päringu sisusse, seejärel saatke päring järelduse lõpp-punkti.

Selles lahenduses rakendame RESTful API-t, et saavutada eelmistes sammudes kirjeldatud reaalajas petturlik ennustus. Reaalajas prognooside jaoks vaadake järgmist pseudokoodi. Täielik rakendamine on käes täielik lähtekoodifail.

Reaalajas ennustamiseks nõuavad esimesed kolm sammu väiksemat latentsust. Seetõttu on graafikute andmebaas nende ülesannete jaoks optimaalne valik, eriti alamgraafide ekstraheerimiseks, mida saab tõhusalt saavutada graafiku andmebaasi päringute abil. Pseudokoodi toetavad allajoonimisfunktsioonid põhinevad Neptuuni gremlini päringutel.

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

Üks hoiatus GNN-ide abil reaalajas pettuste tuvastamisel on GNN-i järeldusrežiim. Reaalajas järelduse täitmiseks peame teisendama GNN-mudeli järelduse transduktiivsest režiimist induktiivseks režiimiks. GNN-i mudelid transduktiivses järeldusrežiimis ei saa ennustada äsja ilmunud sõlmede ja servade kohta, samas kui induktiivses režiimis saavad GNN-i mudelid hakkama uute sõlmede ja servadega. Transduktiivse ja induktiivse režiimi erinevuse demonstratsioon on näidatud järgmisel joonisel.

Transduktiivses režiimis eksisteerivad ennustatud sõlmed ja servad treeningu ajal koos märgistatud sõlmede ja servadega. Mudelid tuvastavad need enne järeldusi ja neid saab järeldada koolituse käigus. Induktiivses režiimis olevaid mudeleid treenitakse treeninggraafikul, kuid nad peavad ennustama nähtamatuid sõlme (paremal punase punktiirringiga) koos nendega seotud naabritega, mis võivad olla uued sõlmed, nagu parempoolne hall kolmnurga sõlm.

Meie RGCN-i mudelit on koolitatud ja testitud transduktiivses režiimis. Sellel on juurdepääs kõikidele koolitusel olevatele sõlmedele ning see on välja õpetanud iga funktsioonideta sõlme (nt IP-aadressi ja kaarditüübi) manustamise. Testimisetapis kasutab RGCN-mudel neid manuseid sõlmefunktsioonidena, et ennustada testikomplekti sõlme. Kui teeme reaalajas järeldusi, siis mõnel äsja lisatud funktsioonita sõlmel pole selliseid manuseid, kuna neid pole treeninggraafikus. Üks viis selle probleemi lahendamiseks on määrata uutele sõlmedele kõigi sama sõlmetüübi manustuste keskmine. Selles lahenduses kasutame seda meetodit.

Lisaks pakub see lahendus veebiportaali (nagu on näha järgmisel ekraanipildil), et näidata reaalajas petturlikke ennustusi ettevõtjate vaatenurgast. See võib genereerida simuleeritud võrgutehinguid ja pakkuda tuvastatud pettusteabe reaalajas visualiseerimist.

Koristage

Kui olete lahenduse uurimise lõpetanud, saate seda teha puhastada ressursse et vältida tasusid.

Järeldus

Selles postituses näitasime, kuidas SageMakeri, Neptune'i ja DGL-i abil luua GNN-põhine reaalajas pettuste tuvastamise lahendus. Sellel lahendusel on kolm peamist eelist:

• Sellel on ennustustäpsuse ja AUC-mõõdikute osas hea jõudlus
• See võib teha reaalajas järeldusi voogesituse MLOps torujuhtme ja SageMakeri lõpp-punktide kaudu
• See automatiseerib kogu juurutusprotsessi kaasasoleva CloudFormationi malliga, et huvitatud arendajad saaksid seda lahendust oma konto kohandatud andmetega hõlpsasti testida.

Lisateavet lahenduse kohta leiate aadressilt GitHub repo.

Pärast selle lahenduse juurutamist soovitame kohandada andmetöötluskoodi nii, et see sobiks teie enda andmevorminguga, ja muuta reaalajas järeldusmehhanismi, jättes GNN-i mudeli muutmata. Pange tähele, et jagame reaalajas tehtud järeldused neljaks etapiks ilma latentsust täiendavalt optimeerimata. Need neli sammu võtavad demoandmete kogumi kohta prognoosi saamiseks mõne sekundi. Usume, et Neptune'i graafiku andmeskeemi kujunduse ja päringute optimeerimine alamgraafide ja funktsioonide ekstraheerimiseks võib märkimisväärselt vähendada järelduste latentsust.

Autoritest

Jian Zhang on rakendusteadlane, kes on kasutanud masinõppe tehnikaid, et aidata klientidel lahendada erinevaid probleeme, nagu pettuste tuvastamine, dekoratsioonipiltide genereerimine ja palju muud. Ta on edukalt arendanud graafipõhist masinõpet, eriti graafilise närvivõrgu lahendusi klientidele Hiinas, USA-s ja Singapuris. AWS-i graafikuvõimaluste selgitajana on Zhang pidanud palju avalikke esitlusi GNN-i, sügava graafiku raamatukogu (DGL), Amazon Neptune'i ja muude AWS-teenuste kohta.

Mengxin Zhu on AWS-i Solutions Architectsi juht, keskendudes korduvkasutatavate AWS-lahenduste kavandamisele ja arendamisele. Ta on aastaid tegelenud tarkvaraarendusega ning vastutanud mitme erineva suurusega startup meeskonna eest. Ta on ka avatud lähtekoodiga tarkvara pooldaja ja oli Eclipse Committer.

Haozhu Wang on teadur Amazon ML Solutions Labis, kus ta juhib kaasjuhtimist tugevdamise õppevertikaalis. Ta aitab klientidel luua täiustatud masinõppelahendusi, kasutades uusimaid uuringuid graafikute õppimise, loomuliku keele töötlemise, armeerimisõppe ja AutoML-i kohta. Haozhu sai doktorikraadi elektri- ja arvutitehnika alal Michigani ülikoolist.