Zgradite rešitev za odkrivanje goljufij v realnem času, ki temelji na GNN, z uporabo Amazon SageMaker, Amazon Neptune in Deep Graph Library

Goljufive dejavnosti resno vplivajo na številne industrije, kot so e-trgovina, družbeni mediji in finančne storitve. Goljufije lahko povzročijo znatno izgubo za podjetja in potrošnike. Ameriški potrošniki so poročali, da so leta 5.8 zaradi goljufij izgubili več kot 2021 milijarde dolarjev, kar je več kot 70 % več kot leta 2020. Za odkrivanje goljufov je bilo uporabljenih veliko tehnik – filtri na podlagi pravil, zaznavanje nepravilnosti in modeli strojnega učenja (ML), če naštejemo le nekatere.

V podatkih iz resničnega sveta entitete pogosto vključujejo bogate odnose z drugimi entitetami. Takšna struktura grafa lahko zagotovi dragocene informacije za odkrivanje nepravilnosti. Na naslednji sliki so uporabniki na primer povezani prek skupnih entitet, kot so ID-ji Wi-Fi, fizične lokacije in telefonske številke. Zaradi velikega števila edinstvenih vrednosti teh entitet, kot so telefonske številke, jih je težko uporabiti v tradicionalnih modelih, ki temeljijo na funkcijah – na primer, enkratno kodiranje vseh telefonskih številk ne bi bilo izvedljivo. Toda takšni odnosi bi lahko pomagali napovedati, ali je uporabnik goljuf. Če je uporabnik delil več entitet z znanim goljufom, je ta bolj verjetno goljuf.

V zadnjem času je grafična nevronska mreža (GNN) postala priljubljena metoda za odkrivanje goljufij. Modeli GNN lahko kombinirajo strukturo grafa in atribute vozlišč ali robov, kot so uporabniki ali transakcije, da se naučijo smiselnih predstavitev za razlikovanje zlonamernih uporabnikov in dogodkov od zakonitih. Ta zmožnost je ključnega pomena za odkrivanje goljufij, kjer se goljufi dogovarjajo, da skrijejo svoje neobičajne značilnosti, vendar pustijo nekaj sledi odnosov.

Trenutne rešitve GNN se v glavnem zanašajo na paketno usposabljanje brez povezave in način sklepanja, ki zazna goljufe po tem, ko se zgodijo zlonamerni dogodki in izgube. Vendar je lovljenje goljufivih uporabnikov in dejavnosti v realnem času ključnega pomena za preprečevanje izgub. To še posebej velja za poslovne primere, kjer obstaja samo ena možnost za preprečevanje goljufivih dejavnosti. Na primer, na nekaterih platformah za e-trgovino je registracija računa odprta. Goljufi se lahko zlonamerno obnašajo z računom in nikoli več ne uporabijo istega računa.

Predvidevanje goljufov v realnem času je pomembno. Izgradnja takšne rešitve pa je zahtevna. Ker so GNN še vedno novi v panogi, so spletni viri o pretvorbi modelov GNN iz paketnega streženja v streženje v realnem času omejeni. Poleg tega je izziv zgraditi cevovod za pretočne podatke, ki lahko posreduje dohodne dogodke API-ju za streženje GNN v realnem času. Kolikor je avtorjem znano, od tega pisanja niso na voljo nobene referenčne arhitekture in primeri za rešitve sklepanja v realnem času, ki temeljijo na GNN.

Da bi razvijalcem pomagali pri uporabi GNN-jev za odkrivanje goljufij v realnem času, ta objava prikazuje, kako jih uporabljati Amazonski Neptun, Amazon SageMakerIn Knjižnica globokih grafov (DGL), med drugimi storitvami AWS, za izgradnjo rešitve od konca do konca za odkrivanje goljufij v realnem času z uporabo modelov GNN.

Osredotočamo se na štiri naloge:

• Obdelava tabelarnega nabora transakcijskih podatkov v heterogeni nabor podatkov grafa
• Usposabljanje modela GNN z uporabo SageMakerja
• Uvajanje usposobljenih modelov GNN kot končne točke SageMaker
• Prikaz sklepanja v realnem času za dohodne transakcije

Ta objava razširja prejšnje delo v Odkrivanje goljufij v heterogenih omrežjih s pomočjo Amazon SageMaker in knjižnice Deep Graph, ki se osredotoča na prvi dve nalogi. Za več podrobnosti o heterogenih grafih, GNN-jih in delno nadzorovanem usposabljanju GNN-jev se lahko obrnete na to objavo.

Podjetja, ki iščejo popolnoma upravljano storitev AI AWS za odkrivanje goljufij, lahko uporabljajo tudi Amazonski detektor prevare, ki olajša prepoznavanje potencialno goljufivih spletnih dejavnosti, kot je ustvarjanje lažnih računov ali goljufije pri spletnih plačilih.

Pregled rešitev

Ta rešitev vsebuje dva glavna dela.

Prvi del je cevovod, ki obdeluje podatke, usposablja modele GNN in uvaja usposobljene modele. Uporablja se AWS lepilo za obdelavo transakcijskih podatkov in shrani obdelane podatke v oba Amazonski Neptun in Preprosta storitev shranjevanja Amazon (Amazon S3). Nato se sproži izobraževalno opravilo SageMaker za usposabljanje modela GNN na podatkih, shranjenih v Amazon S3, za napovedovanje, ali je transakcija goljufiva. Izurjen model skupaj z drugimi sredstvi se po zaključku usposabljanja shrani nazaj v Amazon S3. Na koncu je shranjeni model razporejen kot končna točka SageMaker. Cevovod orkestrira Korak funkcije AWS, kot je prikazano na naslednji sliki.

Drugi del rešitve izvaja odkrivanje goljufivih transakcij v realnem času. Začne se z API-jem RESTful, ki poizveduje v bazi podatkov grafov v Neptunu, da izvleče podgraf, povezan z dohodno transakcijo. Ima tudi spletni portal, ki lahko simulira poslovne dejavnosti in ustvarja spletne transakcije z goljufivimi in zakonitimi. Spletni portal omogoča vizualizacijo odkrivanja prevar v živo. Ta del uporablja Amazon CloudFront, Ojačaj AWS, AWS AppSync, Amazon API Gateway, Step funkcije in Amazonski dokumentDB za hitro izdelavo spletne aplikacije. Naslednji diagram prikazuje postopek sklepanja v realnem času in spletni portal.

Implementacija te rešitve, skupaj z an Oblikovanje oblaka AWS predloga, ki lahko zažene arhitekturo v vašem računu AWS, je javno dostopna prek naslednjega GitHub repo.

Obdelava podatkov

V tem razdelku na kratko opisujemo, kako obdelati primer nabora podatkov in ga pretvoriti iz neobdelanih tabel v graf z relacijami, identificiranimi med različnimi stolpci.

Ta rešitev uporablja isti nabor podatkov, Podatkovni niz IEEE-CIS, kot prejšnja objava Odkrivanje goljufij v heterogenih omrežjih s pomočjo Amazon SageMaker in knjižnice Deep Graph. Zato je osnovni princip podatkovnega procesa enak. Na kratko, nabor podatkov o goljufijah vključuje tabelo transakcij in tabelo identitet, ki vsebuje skoraj 500,000 anonimiziranih zapisov transakcij skupaj s kontekstualnimi informacijami (na primer naprave, uporabljene pri transakcijah). Nekatere transakcije imajo binarno oznako, ki označuje, ali je transakcija goljufiva. Naša naloga je predvideti, katere neoznačene transakcije so goljufive in katere zakonite.

Naslednja slika ponazarja splošen postopek pretvorbe tabel IEEE v heterogeni graf. Iz vsake tabele najprej izluščimo dva stolpca. En stolpec je vedno stolpec ID transakcije, kjer nastavimo vsak edinstven ID transakcije kot eno vozlišče. Drugi stolpec je izbran iz kategoričnih stolpcev, kot sta stolpca ProductCD in id_03, kjer je bila vsaka edinstvena kategorija nastavljena kot vozlišče. Če se ID transakcije in edinstvena kategorija pojavita v isti vrstici, ju povežemo z enim robom. Na ta način pretvorimo dva stolpca v tabeli v enega dvodelnega. Nato te bipartite združimo skupaj z vozlišči TransactionID, kjer se ista vozlišča TransactionID združijo v eno edinstveno vozlišče. Po tem koraku imamo heterogeni graf, zgrajen iz bipartitov.

Preostale stolpce, ki se ne uporabljajo za izdelavo grafa, jih združimo kot značilnost vozlišč TransactionID. Vrednosti ID transakcije, ki imajo vrednosti isFraud, se uporabljajo kot oznaka za usposabljanje modela. Na podlagi tega heterogenega grafa naša naloga postane naloga klasifikacije vozlišč vozlišč TransactionID. Za več podrobnosti o pripravi podatkov grafa za usposabljanje GNN glejte Izvleček lastnosti in Konstruiranje grafa razdelke prejšnje objave v spletnem dnevniku.

Koda, uporabljena v tej rešitvi, je na voljo v src/scripts/glue-etl.py. Prav tako lahko eksperimentirate z obdelavo podatkov prek prenosnega računalnika Jupyter src/sagemaker/01.FD_SL_Process_IEEE-CIS_Dataset.ipynb.

Namesto ročne obdelave podatkov, kot je bilo storjeno v prejšnji objavi, ta rešitev uporablja popolnoma samodejni cevovod, ki ga upravljata Step Functions in AWS Glue, ki podpira vzporedno obdelavo ogromnih nizov podatkov prek Apache Spark. Potek dela funkcij korakov je napisan v Komplet za razvoj oblaka AWS (AWS CDK). Sledi a delček kode ustvarite ta potek dela:

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

Poleg konstruiranja podatkov grafa za usposabljanje modela GNN ta potek dela tudi paketno naloži podatke grafa v Neptune za kasnejše sklepanje v realnem času. Ta paketni postopek nalaganja podatkov je prikazan v naslednjem delčku kode:

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

Usposabljanje modela GNN

Ko so podatki grafa za usposabljanje modela shranjeni v Amazon S3, a Usposabljanje SageMaker, ki se zaračuna samo, ko se izobraževalno opravilo izvaja, se sproži za začetek procesa usposabljanja modela GNN v načinu Bring Your Own Container (BYOC). Omogoča vam, da svoje skripte za usposabljanje modela in odvisnosti zapakirate v sliko Docker, ki jo uporablja za ustvarjanje primerkov za usposabljanje SageMaker. Metoda BYOC bi lahko prihranila veliko truda pri postavljanju okolja za usposabljanje. notri src/sagemaker/02.FD_SL_Build_Training_Container_Test_Local.ipynb, najdete podrobnosti o usposabljanju modela GNN.

Slika Dockerja

Prvi del datoteke zvezka Jupyter je generiranje slike Docker za usposabljanje (glejte naslednji delček kode):

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

Za usposabljanje modela smo uporabili sliko, ki temelji na PyTorchu. Knjižnica globokih grafov (DGL) in druge odvisnosti so nameščene pri izdelavi slike Docker. Koda modela GNN v src/sagemaker/FD_SL_DGL/gnn_fraud_detection_dgl mapa se kopira tudi na sliko.

Ker transakcijske podatke obdelamo v heterogeni graf, v tej rešitvi izberemo Konvolucijska mreža relacijskega grafa (RGCN), ki je zasnovan posebej za heterogene grafe. Naš model RGCN lahko uri učljive vdelave za vozlišča v heterogenih grafih. Nato se naučene vdelave uporabijo kot vhodi popolnoma povezane plasti za napovedovanje oznak vozlišč.

Hiperparametri

Za usposabljanje GNN moramo pred postopkom usposabljanja definirati nekaj hiperparametrov, kot so imena datotek izdelanega grafa, število slojev modelov GNN, obdobja usposabljanja, optimizator, parametri optimizacije in več. Oglejte si naslednjo kodo za podmnožico konfiguracij:

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}

Za več informacij o vseh hiperparametrih in njihovih privzetih vrednostih glejte estimator_fns.py v src/sagemaker/FD_SL_DGL/gnn_fraud_detection_dgl mapa.

Usposabljanje modela s SageMakerjem

Ko je izdelana prilagojena slika Docker vsebnika, uporabimo predhodno obdelane podatke za usposabljanje našega modela GNN s hiperparametri, ki smo jih definirali. Usposabljanje uporablja DGL s PyTorchom kot ogrodjem globokega učenja v ozadju za izdelavo in usposabljanje GNN. SageMaker olajša usposabljanje modelov GNN s prilagojeno sliko Docker, ki je vhodni argument ocenjevalca SageMaker. Za več informacij o usposabljanju GNN-jev z DGL na SageMakerju glejte Usposobite mrežo globokih grafov.

SDK SageMaker Python uporablja Ocenjevalnik za enkapsulacijo usposabljanja na SageMakerju, ki poganja vsebnike Docker po meri, združljive s SageMakerjem, kar vam omogoča izvajanje lastnih algoritmov ML z uporabo SDK SageMaker Python. Naslednji delček kode prikazuje usposabljanje modela s SageMakerjem (bodisi v lokalnem okolju bodisi v oblaku):

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)

Po usposabljanju je zmogljivost modela GNN na testnem nizu prikazana kot naslednji rezultati. Model RGCN lahko običajno doseže približno 0.87 AUC in več kot 95-odstotno natančnost. Za primerjavo modela RGCN z drugimi modeli ML glejte Rezultati razdelek prejšnje objave v spletnem dnevniku za več podrobnosti.

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

Po zaključku usposabljanja modela SageMaker zapakira usposobljeni model skupaj z drugimi sredstvi, vključno z vdelavami usposobljenih vozlišč, v datoteko ZIP in jo nato naloži na določeno lokacijo S3. Nato razpravljamo o uvedbi usposobljenega modela za odkrivanje goljufij v realnem času.

Uvedba modela GNN

SageMaker poenostavi uvajanje usposobljenih modelov ML. Na tej stopnji uporabljamo razred SageMaker PyTorchModel za uvajanje usposobljenega modela, ker je naš model DGL odvisen od PyTorcha kot zalednega ogrodja. Kodo za uvajanje najdete v src/sagemaker/03.FD_SL_Endpoint_Deployment.ipynb Datoteka.

Poleg datoteke in sredstev usposobljenega modela SageMaker zahteva datoteko vstopne točke za uvedbo prilagojenega modela. Datoteka vstopne točke se zažene in shrani v pomnilnik instance končne točke sklepanja, da odgovori na zahtevo za sklepanje. V našem primeru je datoteka vstopne točke fd_sl_deployment_entry_point.py datoteko v src/sagemaker/FD_SL_DGL/code mapo, ki opravlja štiri glavne funkcije:

• Prejemajte zahteve in razčlenjujte vsebino zahtev za pridobitev vozlišč, ki jih je treba predvideti, in z njimi povezanih podatkov
• Pretvorite podatke v heterogeni graf DGL kot vhod za model RGCN
• Izvedite sklepanje v realnem času prek usposobljenega modela RGCN
• Vrnite rezultate napovedi vlagatelju zahteve

Po konvencijah SageMaker sta prvi dve funkciji implementirani v input_fn metoda. Oglejte si naslednjo kodo (zaradi poenostavitve izbrišemo nekaj kode komentarja):

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)

Konstruirani graf DGL in funkcije se nato posredujejo v predict_fn metoda za izpolnitev tretje funkcije. predict_fn sprejme dva vhodna argumenta: izhode input_fn in izurjen model. Oglejte si naslednjo kodo:

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]

Model, uporabljen v perdict_fn je ustvaril model_fn metoda, ko je končna točka poklicana prvič. Funkcija model_fn naloži shranjeno datoteko modela in povezana sredstva iz model_dir argument in mapo modela SageMaker. Oglejte si naslednjo kodo:

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

Rezultat predict_fn metoda je seznam dveh številk, ki označujeta logite za razred 0 in razred 1, kjer 0 pomeni zakonito in 1 goljufivo. SageMaker vzame ta seznam in ga posreduje notranji metodi, imenovani output_fn za dokončanje končne funkcije.

Za uvedbo našega modela GNN najprej zavijemo model GNN v razred SageMaker PyTorchModel z datoteko vstopne točke in drugimi parametri (pot shranjene datoteke ZIP, različica ogrodja PyTorch, različica Python itd.). Nato pokličemo njegovo metodo razmestitve z nastavitvami instance. Oglejte si naslednjo kodo:

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

Prejšnji postopki in izrezki kode prikazujejo, kako razmestiti svoj model GNN kot končno točko spletnega sklepanja iz prenosnega računalnika Jupyter. Vendar pa za proizvodnjo priporočamo uporabo prej omenjenega cevovoda MLOps, ki ga usmerjajo funkcije Step Functions za celoten potek dela, vključno z obdelavo podatkov, usposabljanjem modela in uvajanjem končne točke sklepanja. Celoten cevovod izvaja AWS CDK uporaba, ki ga je mogoče preprosto posnemati v različnih regijah in računih.

Sklepanje v realnem času

Ko prispe nova transakcija, moramo za izvedbo predvidevanja v realnem času opraviti štiri korake:

1. Vstavljanje vozlišča in robov – Ekstrahirajte informacije o transakciji, kot sta ID transakcije in ProductCD, kot vozlišča in robove ter vstavite nova vozlišča v obstoječe podatke grafa, shranjene v bazi podatkov Neptune.
2. Ekstrakcija podgrafov – Nastavite predvideno transakcijsko vozlišče kot osrednje vozlišče in ekstrahirajte podgraf n-hop v skladu z vhodnimi zahtevami modela GNN.
3. Izvleček lastnosti – Za vozlišča in robove v podgrafu izvlecite njihove povezane značilnosti.
4. Pokličite končno točko sklepanja – Zapakirajte podgraf in funkcije v vsebino zahteve, nato pa zahtevo pošljite končni točki sklepanja.

V tej rešitvi implementiramo RESTful API za doseganje goljufive napovedi v realnem času, opisano v prejšnjih korakih. Oglejte si naslednjo psevdokodo za napovedi v realnem času. Celotna izvedba je v celotno datoteko izvorne kode.

Za predvidevanje v realnem času prvi trije koraki zahtevajo nižjo zakasnitev. Zato je baza podatkov grafov optimalna izbira za te naloge, zlasti za ekstrakcijo podgrafov, kar bi lahko učinkovito dosegli s poizvedbami baze podatkov grafov. Podčrtane funkcije, ki podpirajo psevdo kodo, temeljijo na poizvedbah gremlin Neptuna.

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

Eno opozorilo glede odkrivanja goljufij v realnem času z uporabo GNN je način sklepanja GNN. Za izvedbo sklepanja v realnem času moramo sklepanje modela GNN pretvoriti iz transduktivnega načina v induktivni način. Modeli GNN v transduktivnem načinu sklepanja ne morejo predvideti novonastalih vozlišč in robov, medtem ko lahko v induktivnem načinu modeli GNN obravnavajo nova vozlišča in robove. Prikaz razlike med transduktivnim in induktivnim načinom je prikazan na naslednji sliki.

V transduktivnem načinu med usposabljanjem predvidena vozlišča in robovi sobivajo z označenimi vozlišči in robovi. Modeli jih identificirajo pred sklepanjem in jih je mogoče sklepati med usposabljanjem. Modeli v induktivnem načinu se urijo na učnem grafu, vendar morajo predvideti nevidna vozlišča (tista v rdečih pikčastih krogih na desni) z njihovimi povezanimi sosedi, ki so lahko nova vozlišča, kot je vozlišče sivega trikotnika na desni.

Naš model RGCN je usposobljen in preizkušen v transduktivnem načinu. Ima dostop do vseh vozlišč v usposabljanju in je tudi usposobil vdelavo za vsako vozlišče brez funkcij, kot so naslov IP in vrste kartic. V fazi testiranja model RGCN te vdelave uporablja kot funkcije vozlišč za napovedovanje vozlišč v testnem nizu. Ko sklepamo v realnem času, pa nekatera na novo dodana vozlišča brez funkcij nimajo takšnih vdelav, ker niso v učnem grafu. Eden od načinov za reševanje te težave je dodelitev povprečja vseh vdelav v isto vrsto vozlišča novim vozliščem. V tej rešitvi uporabljamo to metodo.

Poleg tega ta rešitev ponuja spletni portal (kot je prikazan na naslednjem posnetku zaslona) za prikaz goljufivih napovedi v realnem času z vidika poslovnih subjektov. Ustvari lahko simulirane spletne transakcije in zagotovi vizualizacijo zaznanih goljufivih informacij o transakcijah v živo.

Čiščenje

Ko končate z raziskovanjem rešitve, lahko čisti vire da se izognete stroškom.

zaključek

V tej objavi smo pokazali, kako zgraditi rešitev za odkrivanje goljufij v realnem času, ki temelji na GNN, z uporabo SageMaker, Neptune in DGL. Ta rešitev ima tri glavne prednosti:

• Ima dobro zmogljivost v smislu natančnosti napovedi in meritev AUC
• Izvaja lahko sklepanje v realnem času prek pretočnega cevovoda MLOps in končnih točk SageMaker
• Avtomatizira celoten postopek uvajanja s priloženo predlogo CloudFormation, tako da lahko zainteresirani razvijalci preprosto preizkusijo to rešitev s podatki po meri v svojem računu

Za več podrobnosti o rešitvi glejte GitHub repo.

Ko uvedete to rešitev, priporočamo, da prilagodite kodo za obdelavo podatkov, da bo ustrezala vašemu formatu podatkov, in spremenite mehanizem sklepanja v realnem času, medtem ko model GNN ostane nespremenjen. Upoštevajte, da smo sklepanje v realnem času razdelili na štiri korake brez dodatne optimizacije zakasnitve. Ti štirje koraki trajajo nekaj sekund, da dobite napoved na predstavitvenem naboru podatkov. Verjamemo, da lahko optimizacija zasnove podatkovne sheme grafa Neptune in poizvedb za podgraf in ekstrakcijo funkcij znatno zmanjša zakasnitev sklepanja.

O avtorjih

Jian Zhang je uporabni znanstvenik, ki uporablja tehnike strojnega učenja za pomoč strankam pri reševanju različnih težav, kot so odkrivanje goljufij, ustvarjanje okrasnih slik in drugo. Uspešno je razvil grafično temelječe strojno učenje, zlasti grafične nevronske mreže, rešitve za stranke na Kitajskem, v ZDA in Singapurju. Kot razsvetljevalec zmogljivosti grafov AWS je imel Zhang veliko javnih predstavitev o GNN, Deep Graph Library (DGL), Amazon Neptune in drugih storitvah AWS.

Mengxin Zhu je vodja arhitektov rešitev pri AWS, s poudarkom na oblikovanju in razvoju rešitev AWS za večkratno uporabo. Že vrsto let se ukvarja z razvojem programske opreme in je odgovoren za več startup ekip različnih velikosti. Je tudi zagovornik odprtokodne programske opreme in je sodeloval pri Eclipse Committer.

Haozhu Wang je raziskovalec pri Amazon ML Solutions Lab, kjer sovodi Vertikalo za krepitveno učenje. Strankam pomaga zgraditi napredne rešitve strojnega učenja z najnovejšimi raziskavami o učenju grafov, obdelavi naravnega jezika, okrepljenem učenju in AutoML. Haozhu je doktoriral iz elektrotehnike in računalništva na Univerzi v Michiganu.