בנה פתרון זיהוי הונאה בזמן אמת מבוסס GNN באמצעות Amazon SageMaker, Amazon Neptune ו-Deep Graph Library

פעילויות הונאה משפיעות קשות על תעשיות רבות, כגון מסחר אלקטרוני, מדיה חברתית ושירותים פיננסיים. הונאות עלולות לגרום להפסד משמעותי לעסקים ולצרכנים. צרכנים אמריקאים דיווחו שהפסידו יותר מ-5.8 מיליארד דולר כתוצאה מהונאות ב-2021, עלייה של יותר מ-70% לעומת 2020. נעשה שימוש בטכניקות רבות לאיתור רמאים - מסננים מבוססי כללים, זיהוי חריגות ולמידת מכונה (ML), אם להזכיר כמה.

בנתונים מהעולם האמיתי, ישויות כרוכות לעתים קרובות בקשרים עשירים עם ישויות אחרות. מבנה גרף כזה יכול לספק מידע רב ערך לזיהוי אנומליות. לדוגמה, באיור הבא, משתמשים מחוברים באמצעות ישויות משותפות כגון מזהי Wi-Fi, מיקומים פיזיים ומספרי טלפון. בשל המספר הגדול של ערכים ייחודיים של ישויות אלה, כמו מספרי טלפון, קשה להשתמש בהם בדגמים המסורתיים מבוססי תכונות - לדוגמה, קידוד חד-חם של כל מספרי הטלפון לא יהיה בר-קיימא. אבל יחסים כאלה יכולים לעזור לחזות אם משתמש הוא רמאי. אם משתמש שיתף מספר ישויות עם רמאי ידוע, סביר יותר שהמשתמש הוא רמאי.

לאחרונה, רשת עצבית גרפית (GNN) הפכה לשיטה פופולרית לגילוי הונאה. מודלים של GNN יכולים לשלב גם מבנה גרף וגם תכונות של צמתים או קצוות, כגון משתמשים או עסקאות, כדי ללמוד ייצוגים משמעותיים כדי להבחין בין משתמשים זדוניים ואירועים לגיטימיים. יכולת זו חיונית לאיתור הונאות שבהן רמאים משתפים פעולה כדי להסתיר את תכונותיהם החריגות אך משאירים כמה עקבות של יחסים.

הפתרונות הנוכחיים של GNN מסתמכים בעיקר על אימון אצווה לא מקוון ועל מצב הסקה, המזהים רמאים לאחר שקרו אירועים זדוניים והתרחשו הפסדים. עם זאת, תפיסת משתמשים ופעילויות הונאה בזמן אמת היא חיונית למניעת הפסדים. זה נכון במיוחד במקרים עסקיים שבהם יש רק סיכוי אחד למנוע פעולות הונאה. לדוגמה, בחלק מפלטפורמות המסחר האלקטרוני, רישום החשבון פתוח לרווחה. רמאים יכולים להתנהג בזדון רק פעם אחת עם חשבון ולעולם לא להשתמש באותו חשבון שוב.

חיזוי רמאים בזמן אמת חשוב. אולם בניית פתרון כזה היא מאתגרת. מכיוון ש-GNNs עדיין חדשים בתעשייה, ישנם משאבים מקוונים מוגבלים להמרת דגמי GNN מהגשה אצווה להגשה בזמן אמת. בנוסף, זה מאתגר לבנות צינור זרימת נתונים שיכול להזין אירועים נכנסים ל-API המשרת GNN בזמן אמת. למיטב ידיעת המחברים, אין ארכיטקטורות ייחוס ודוגמאות זמינות עבור פתרונות מסקנות בזמן אמת מבוססי GNN נכון לכתיבת שורות אלה.

כדי לעזור למפתחים להחיל GNNs לזיהוי הונאה בזמן אמת, פוסט זה מראה כיצד להשתמש אמזון נפטון, אמזון SageMaker, וה ספריית גרפים עמוקים (DGL), בין יתר שירותי AWS, לבניית פתרון מקצה לקצה לגילוי הונאה בזמן אמת באמצעות מודלים של GNN.

אנו מתמקדים בארבע משימות:

• עיבוד מערך נתונים טבלאי של עסקאות למערך נתונים הטרוגני של גרפים
• הכשרת מודל GNN באמצעות SageMaker
• פריסת דגמי GNN המאומנים כנקודת קצה של SageMaker
• הדגמת מסקנות בזמן אמת עבור עסקאות נכנסות

פוסט זה מרחיב את העבודה הקודמת ב גילוי הונאה ברשתות הטרוגניות באמצעות אמזון SageMaker וספריית הגרפים העמוקים, המתמקד בשתי המשימות הראשונות. אתה יכול לעיין בפוסט הזה לפרטים נוספים על גרפים הטרוגניים, GNNs והדרכה למחצה מפוקחת של GNNs.

עסקים המחפשים שירות AWS AI מנוהל במלואו לזיהוי הונאה יכולים גם להשתמש גלאי הונאות של אמזון, מה שמקל על זיהוי פעילויות מקוונות העלולות להונאות, כגון יצירת חשבונות מזויפים או הונאת תשלומים מקוונת.

סקירת פתרונות

פתרון זה מכיל שני חלקים עיקריים.

החלק הראשון הוא צינור שמעבד את הנתונים, מאמן דגמי GNN ופורס את המודלים המאומנים. זה משתמש דבק AWS לעבד את נתוני העסקה, ושומר את הנתונים המעובדים לשניהם אמזון נפטון ו שירות אחסון פשוט של אמזון (אמזון S3). לאחר מכן, משרת אימון של SageMaker מופעלת כדי להכשיר מודל GNN על הנתונים שנשמרו באמזון S3 כדי לחזות אם עסקה היא הונאה. הדגם המאומן יחד עם נכסים אחרים נשמרים בחזרה לאמזון S3 עם השלמת עבודת ההדרכה. לבסוף, המודל השמור נפרס כנקודת קצה של SageMaker. הצינור מתוזמר על ידי פונקציות שלב AWS, כפי שמוצג באיור הבא.

החלק השני של הפתרון מיישם זיהוי עסקאות הונאה בזמן אמת. זה מתחיל מממשק API של RESTful שמבקש את מסד הנתונים של הגרפים ב-Neptune כדי לחלץ את התת-גרף הקשור לעסקה נכנסת. יש לו גם פורטל אינטרנט שיכול לדמות פעילויות עסקיות, וליצור עסקאות מקוונות עם הונאה ולגיטימיות כאחד. פורטל האינטרנט מספק הדמיה חיה של גילוי ההונאה. חלק זה משתמש אמזון CloudFront, AWS להגביר, AWS AppSync, שער API של אמזון, פונקציות צעד, ו DocumentDB של אמזון לבנות במהירות את אפליקציית האינטרנט. התרשים הבא ממחיש את תהליך ההסקה בזמן אמת ואת פורטל האינטרנט.

יישום פתרון זה, יחד עם א AWS CloudFormation תבנית שיכולה להפעיל את הארכיטקטורה בחשבון ה-AWS שלך, זמינה לציבור דרך הפריטים הבאים GitHub ריפו.

עיבוד נתונים

בסעיף זה, אנו מתארים בקצרה כיצד לעבד מערך נתונים לדוגמה ולהמיר אותו מטבלאות גולמיות לגרף עם קשרים המזוהים בין עמודות שונות.

פתרון זה משתמש באותו מערך נתונים, ה- מערך הונאות IEEE-CIS, כמו הפוסט הקודם גילוי הונאה ברשתות הטרוגניות באמצעות אמזון SageMaker וספריית הגרפים העמוקים. לכן, העיקרון הבסיסי של תהליך הנתונים זהה. בקצרה, מערך ההונאה כולל טבלת עסקאות וטבלת זהויות, עם כמעט 500,000 רשומות עסקאות אנונימיות יחד עם מידע הקשרי (לדוגמה, מכשירים המשמשים בעסקאות). לחלק מהעסקאות יש תווית בינארית, המציינת אם עסקה היא הונאה. המשימה שלנו היא לחזות אילו עסקאות ללא תווית הן הונאה ואילו לגיטימיות.

האיור הבא ממחיש את התהליך הכללי כיצד להמיר את טבלאות ה-IEEE לגרף הטרוגני. תחילה אנו מחלצים שתי עמודות מכל טבלה. עמודה אחת היא תמיד העמודה מזהה העסקה, שבה אנו מגדירים כל TransactionID ייחודי כצומת אחד. עמודה נוספת נבחרה מהעמודות הקטגוריות, כגון העמודות ProductCD ו-id_03, שבהן כל קטגוריה ייחודית הוגדרה כצומת. אם TransactionID וקטגוריה ייחודית מופיעים באותה שורה, אנו מחברים אותם עם קצה אחד. בדרך זו, אנו ממירים שתי עמודות בטבלה לדו-חלקי אחד. לאחר מכן אנו משלבים את הדו-חלקים הללו יחד עם צמתי ה-TransactionID, כאשר אותם צמתי TransactionID מתמזגים לצומת ייחודי אחד. לאחר שלב זה, יש לנו גרף הטרוגני הבנוי מדו-חלקיות.

עבור שאר העמודות שאינן משמשות לבניית הגרף, אנו מצטרפים אותן יחד כתכונה של צמתי ה-TransactionID. ערכי TransactionID בעלי ערכי isFraud משמשים כתווית לאימון מודלים. בהתבסס על הגרף ההטרוגני הזה, המשימה שלנו הופכת למשימת סיווג צמתים של צמתי ה-TransactionID. לפרטים נוספים על הכנת נתוני הגרף לאימון GNNs, עיין ב- חילוץ תכונה ו בניית הגרף חלקים של הפוסט הקודם בבלוג.

הקוד המשמש בפתרון זה זמין ב src/scripts/glue-etl.py. אתה יכול גם להתנסות בעיבוד נתונים דרך מחברת Jupyter src/sagemaker/01.FD_SL_Process_IEEE-CIS_Dataset.ipynb.

במקום לעבד את הנתונים באופן ידני, כפי שנעשה בפוסט הקודם, פתרון זה משתמש בצינור אוטומטי לחלוטין המתוזמן על ידי Step Functions ו-AWS Glue התומך בעיבוד מערכי נתונים ענקיים במקביל דרך Apache Spark. זרימת העבודה של Step Functions כתובה ערכת פיתוח ענן AWS (AWS CDK). להלן א קטע קוד כדי ליצור זרימת עבודה זו:

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

מלבד בניית נתוני הגרף עבור אימון מודל GNN, זרימת עבודה זו גם טוענת את נתוני הגרף לנפטון כדי לבצע הסקת מסקנות בזמן אמת בהמשך. תהליך טעינת נתוני אצווה זה מודגם בקטע הקוד הבא:

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

לאחר שמירת נתוני הגרף לאימון המודל באמזון S3, א עבודת הדרכה של SageMaker, אשר נטען רק כאשר עבודת ההדרכה פועלת, מופעל כדי להתחיל את תהליך ההדרכה של מודל GNN במצב Bring Your Own Container (BYOC). זה מאפשר לך לארוז את סקריפטי ההדרכה והתלות של המודל שלך בתמונת Docker, שבה הוא משתמש כדי ליצור מופעי אימון של SageMaker. שיטת BYOC יכולה לחסוך מאמץ משמעותי בהקמת סביבת האימון. ב src/sagemaker/02.FD_SL_Build_Training_Container_Test_Local.ipynb, תוכל למצוא פרטים על הכשרת מודל GNN.

תמונת דוקר

החלק הראשון של קובץ המחברת של Jupyter הוא יצירת התמונות של Docker האימון (ראה את קטע הקוד הבא):

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

השתמשנו בתמונה מבוססת PyTorch עבור אימון המודל. ספריית הגרפים העמוקים (DGL) ותלות אחרות מותקנים בעת בניית תמונת Docker. קוד הדגם של GNN ב- src/sagemaker/FD_SL_DGL/gnn_fraud_detection_dgl התיקייה מועתקת לתמונה גם כן.

מכיוון שאנו מעבדים את נתוני העסקאות לגרף הטרוגני, בפתרון זה אנו בוחרים את Relational Graph Convolutional Network מודל (RGCN), אשר תוכנן במיוחד עבור גרפים הטרוגניים. מודל RGCN שלנו יכול לאמן הטבעות הניתנות ללמידה עבור הצמתים בגרפים הטרוגניים. לאחר מכן, ההטבעות הנלמדות משמשות ככניסות של שכבה מחוברת במלואה לניבוי תוויות הצומת.

היפרפרמטרים

כדי להכשיר את ה-GNN, עלינו להגדיר כמה היפרפרמטרים לפני תהליך האימון, כגון שמות הקבצים של הגרף שנבנה, מספר השכבות של מודלים של GNN, תקופות האימון, האופטימיזציה, פרמטרי האופטימיזציה ועוד. ראה את הקוד הבא עבור תת-קבוצה של התצורות:

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}

למידע נוסף על כל הפרמטרים ההיפר וערכי ברירת המחדל שלהם, ראה estimator_fns.py ב src/sagemaker/FD_SL_DGL/gnn_fraud_detection_dgl תיקייה.

אימון דוגמניות עם SageMaker

לאחר בניית תמונת הדוקר המותאמת אישית, אנו משתמשים בנתונים המעובדים מראש כדי לאמן את מודל ה-GNN שלנו עם ההיפרפרמטרים שהגדרנו. עבודת ההדרכה משתמשת ב-DGL, עם PyTorch כמסגרת הלמידה העמוקה האחורית, כדי לבנות ולהכשיר את ה-GNN. SageMaker מקל על אימון דגמי GNN עם תמונת Docker המותאמת אישית, שהיא ארגומנט קלט של מעריך SageMaker. למידע נוסף על הכשרת GNNs עם DGL ב- SageMaker, ראה הכשר רשת גרפים עמוקה.

ה-SDK של SageMaker Python משתמש מעריך להטמיע הכשרה על SageMaker, המריץ מיכלי Docker מותאמים אישית תואמי SageMaker, המאפשרים לך להפעיל אלגוריתמי ML משלך באמצעות SageMaker Python SDK. קטע הקוד הבא מדגים אימון המודל עם SageMaker (בסביבה מקומית או במופעי ענן):

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)

לאחר האימון, הביצועים של דגם ה-GNN על ערכת הבדיקה מוצגים כמו הפלטים הבאים. מודל RGCN יכול בדרך כלל להגיע ל-0.87 AUC ולמעלה מ-95% דיוק. להשוואה של מודל RGCN עם דגמי ML אחרים, עיין ב- תוצאות קטע של הפוסט הקודם בבלוג לפרטים נוספים.

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

עם השלמת הכשרת המודל, SageMaker אורזת את המודל המאומן יחד עם נכסים אחרים, כולל הטבעות הצומת המאומן, לקובץ ZIP ולאחר מכן מעלה אותו למיקום S3 שצוין. לאחר מכן, נדון בפריסה של המודל המאומן לזיהוי הונאה בזמן אמת.

פריסת מודל GNN

SageMaker הופכת את הפריסה של דגמי ML מאומנים לפשוטה. בשלב זה, אנו משתמשים במחלקה של SageMaker PyTorchModel כדי לפרוס את המודל המאומן, מכיוון שמודל ה-DGL שלנו תלוי ב- PyTorch כמסגרת האחורית. אתה יכול למצוא את קוד הפריסה ב- src/sagemaker/03.FD_SL_Endpoint_Deployment.ipynb קובץ.

מלבד קובץ המודל והנכסים המיומנים, SageMaker דורש קובץ נקודת כניסה לפריסה של מודל מותאם אישית. קובץ נקודת הכניסה מופעל ומאוחסן בזיכרון של מופע נקודת קצה להסקה כדי להגיב לבקשת ההסקה. במקרה שלנו, קובץ נקודת הכניסה הוא ה fd_sl_deployment_entry_point.py הקובץ src/sagemaker/FD_SL_DGL/code תיקייה, המבצעת ארבע פונקציות עיקריות:

• קבלת בקשות ונתח תוכן של בקשות כדי להשיג את הצמתים שיש לחזות והנתונים המשויכים אליהם
• המר את הנתונים לגרף הטרוגני של DGL כקלט עבור מודל RGCN
• בצע את ההסקה בזמן אמת באמצעות מודל ה-RGCN המיומן
• החזר את תוצאות החיזוי למבקש

בעקבות מוסכמות SageMaker, שתי הפונקציות הראשונות מיושמות ב- input_fn שיטה. ראה את הקוד הבא (למען הפשטות, אנו מוחקים קוד פרשנות כלשהו):

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)

לאחר מכן, גרף ה-DGL שנבנה והתכונות מועברים ל- predict_fn שיטה למילוי הפונקציה השלישית. predict_fn לוקח שני ארגומנטים קלט: הפלטים של input_fn והדגם המאומן. ראה את הקוד הבא:

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]

הדגם המשמש ב perdict_fn נוצר על ידי model_fn שיטה כאשר נקודת הקצה נקראת בפעם הראשונה. הפונקציה model_fn טוען את קובץ הדגם השמור והנכסים המשויכים מה- model_dir ארגומנט ותיקיית המודל של SageMaker. ראה את הקוד הבא:

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

התפוקה של predict_fn השיטה היא רשימה של שני מספרים, המציינת את הלוגיטים עבור מחלקה 0 ומחלקה 1, כאשר 0 פירושו לגיטימי ו-1 פירושו הונאה. SageMaker לוקח את הרשימה הזו ומעביר אותה לשיטה פנימית שנקראת output_fn כדי להשלים את הפונקציה הסופית.

כדי לפרוס את מודל ה-GNN שלנו, תחילה אנו עוטפים את מודל ה-GNN במחלקה של SageMaker PyTorchModel עם קובץ נקודת הכניסה ופרמטרים אחרים (הנתיב של קובץ ה-ZIP שנשמר, גרסת המסגרת של PyTorch, גרסת Python וכן הלאה). לאחר מכן אנו קוראים לשיטת הפריסה שלו עם הגדרות מופע. ראה את הקוד הבא:

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

ההליכים הקודמים וקטעי הקוד מדגימים כיצד לפרוס את מודל ה-GNN שלך כנקודת קצה מקוונת ממחברת Jupyter. עם זאת, להפקה, אנו ממליצים להשתמש בצינור MLOps שהוזכר קודם לכן המתוזמר על ידי Step Functions עבור זרימת העבודה כולה, כולל עיבוד נתונים, אימון המודל ופריסה של נקודת קצה. הצינור כולו מיושם על ידי AWS CDK יישום, שניתן לשכפל בקלות באזורים וחשבונות שונים.

הסקה בזמן אמת

כאשר מגיעה עסקה חדשה, כדי לבצע חיזוי בזמן אמת, עלינו לבצע ארבעה שלבים:

1. הכנסת צומת וקצה – חלץ את המידע של העסקה כגון TransactionID ו- ProductCD כצמתים וקצוות, והכנס את הצמתים החדשים לנתוני הגרפים הקיימים המאוחסנים במסד הנתונים של Neptune.
2. חילוץ תת-גרף – הגדר את צומת העסקה שיש לחזות כצומת המרכזי, וחלץ תת-גרף n-hop בהתאם לדרישות הקלט של מודל GNN.
3. חילוץ תכונה - עבור הצמתים והקצוות בתת-גרף, חלץ את התכונות המשויכות להם.
4. התקשר לנקודת הסיום - ארוז את התת-גרף והתכונות לתוך התוכן של בקשה, ולאחר מכן שלח את הבקשה לנקודת הסיום.

בפתרון זה, אנו מיישמים ממשק API של RESTful כדי להשיג חיזוי הונאה בזמן אמת שתוארו בשלבים הקודמים. ראה את הפסאודו-קוד הבא לתחזיות בזמן אמת. היישום המלא כבר בפנים קובץ קוד המקור המלא.

לצורך חיזוי בזמן אמת, שלושת השלבים הראשונים דורשים חביון נמוך יותר. לכן, מסד נתונים של גרפים הוא בחירה אופטימלית עבור משימות אלה, במיוחד עבור מיצוי התת-גרפים, שניתן להשיג ביעילות עם שאילתות מסד נתונים גרפים. פונקציות הקו התחתון התומכות בקוד הפסאודו מבוססות על שאילתות הגרמלין של נפטון.

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

אזהרה אחת לגבי זיהוי הונאה בזמן אמת באמצעות GNNs הוא מצב ההסקת GNN. כדי למלא מסקנות בזמן אמת, עלינו להמיר את מסקנת מודל ה-GNN ממצב מתמר למצב אינדוקטיבי. מודלים של GNN במצב אינדוקטיבי אינדוקטיבי אינם יכולים לבצע חיזויים עבור צמתים וקצוות חדשים שהופיעו, בעוד שבמצב אינדוקטיבי, מודלים של GNN יכולים להתמודד עם צמתים וקצוות חדשים. הדגמה של ההבדל בין מצב התמרה לאינדוקטיבי מוצגת באיור הבא.

במצב התמרה, צמתים וקצוות חזויים מתקיימים יחד עם צמתים וקצוות מסומנים במהלך האימון. מודלים מזהים אותם לפני מסקנות, וניתן היה להסיק מהם באימון. מודלים במצב אינדוקטיבי מאומנים על גרף האימון אך צריכים לחזות צמתים בלתי נראים (אלה במעגלים אדומים מנוקדים מימין) עם שכניהם המשויכים, שעשויים להיות צמתים חדשים, כמו צומת המשולש האפור בצד ימין.

דגם ה-RGCN שלנו מאומן ונבדק במצב התמרה. יש לו גישה לכל הצמתים באימון, וגם הכשיר הטמעה עבור כל צומת חסר תכונה, כגון כתובת IP וסוגי כרטיסים. בשלב הבדיקה, מודל RGCN משתמש בהטמעות אלה כתכונות של צומת כדי לחזות צמתים במערך הבדיקה. עם זאת, כאשר אנו עושים הסקת מסקנות בזמן אמת, לחלק מהצמתים חסרי התכונות החדשים שנוספו אין הטמעות כאלה מכיוון שהם לא נמצאים בגרף האימון. דרך אחת להתמודד עם בעיה זו היא להקצות את הממוצע של כל ההטמעות באותו סוג צומת לצמתים החדשים. בפתרון זה, אנו מאמצים שיטה זו.

בנוסף, פתרון זה מספק פורטל אינטרנט (כפי שניתן לראות בצילום המסך הבא) כדי להדגים תחזיות הונאה בזמן אמת מנקודת מבטם של מפעילי העסק. זה יכול ליצור את העסקאות המקוונות המדומות, ולספק הדמיה חיה של מידע עסקאות הונאה שזוהה.

לנקות את

כשתסיים לחקור את הפתרון, תוכל לנקות את המשאבים כדי להימנע מחיובים.

סיכום

בפוסט זה הראינו כיצד לבנות פתרון זיהוי הונאה בזמן אמת מבוסס GNN באמצעות SageMaker, Neptune ו-DGL. לפתרון זה שלושה יתרונות מרכזיים:

• יש לו ביצועים טובים במונחים של דיוק חיזוי ומדדי AUC
• זה יכול לבצע הסקת מסקנות בזמן אמת באמצעות צינור MLOps סטרימינג ונקודות קצה של SageMaker
• זה הופך את תהליך הפריסה הכולל לאוטומטי עם תבנית CloudFormation המסופקת כך שמפתחים מעוניינים יוכלו לבדוק בקלות את הפתרון הזה עם נתונים מותאמים אישית בחשבון שלהם

לפרטים נוספים על הפתרון, עיין ב- GitHub ריפו.

לאחר פריסת פתרון זה, אנו ממליצים להתאים אישית את קוד עיבוד הנתונים כך שיתאים לפורמט הנתונים שלך ולשנות את מנגנון ההסקה בזמן אמת תוך שמירה על מודל GNN ללא שינוי. שימו לב שפצלנו את ההסקה בזמן אמת לארבעה שלבים ללא אופטימיזציה נוספת של זמן ההשהיה. ארבעת השלבים האלה לוקחים כמה שניות כדי לקבל חיזוי על מערך ההדגמה. אנו מאמינים שאופטימיזציה של עיצוב סכימת נתוני גרף נפטון ושאילתות לחילוץ תת-גרף ותכונה יכולה להפחית באופן משמעותי את זמן ההסקה.

על המחברים

ג'יאן ג'אנג הוא מדען יישומי שמשתמש בטכניקות למידת מכונה כדי לעזור ללקוחות לפתור בעיות שונות, כגון זיהוי הונאה, יצירת תמונות קישוט ועוד. הוא פיתח בהצלחה למידת מכונה מבוססת גרפים, במיוחד רשתות עצביות גרפיות, פתרונות ללקוחות בסין, ארה"ב וסינגפור. כמאיר את יכולות הגרפים של AWS, ג'אנג העניק מצגות פומביות רבות על ה-GNN, ספריית הגרפים העמוקים (DGL), אמזון נפטון ושירותי AWS אחרים.

מנגסין ז'ו הוא מנהל פתרונות אדריכלים ב-AWS, עם התמקדות בתכנון ופיתוח פתרונות AWS לשימוש חוזר. הוא עוסק שנים רבות בפיתוח תוכנה ואחראי על מספר צוותי סטארטאפ בגדלים שונים. הוא גם חסיד של תוכנת קוד פתוח והיה גורם Eclipse Committer.

האוז'ו וואנג הוא מדען מחקר במעבדת פתרונות ML של אמזון, שם הוא מוביל את ה-Reforcement Learning Vertical. הוא עוזר ללקוחות לבנות פתרונות למידת מכונה מתקדמים עם המחקר העדכני ביותר על למידת גרפים, עיבוד שפה טבעית, למידת חיזוק ו-AutoML. האוז'ו קיבל את הדוקטורט שלו בהנדסת חשמל ומחשבים מאוניברסיטת מישיגן.