Xây dựng giải pháp phát hiện gian lận trong thời gian thực dựa trên GNN bằng cách sử dụng Amazon SageMaker, Amazon Neptune và Thư viện đồ thị sâu

Các hoạt động lừa đảo ảnh hưởng nghiêm trọng đến nhiều ngành, chẳng hạn như thương mại điện tử, truyền thông xã hội và dịch vụ tài chính. Gian lận có thể gây ra tổn thất đáng kể cho doanh nghiệp và người tiêu dùng. Người tiêu dùng Mỹ báo cáo mất hơn 5.8 tỷ USD do lừa đảo vào năm 2021, tăng hơn 70% so với năm 2020. Nhiều kỹ thuật đã được sử dụng để phát hiện những kẻ lừa đảo—các bộ lọc dựa trên quy tắc, phát hiện bất thường và mô hình máy học (ML), cùng một số kỹ thuật khác.

Trong dữ liệu thế giới thực, các thực thể thường có mối quan hệ phong phú với các thực thể khác. Cấu trúc biểu đồ như vậy có thể cung cấp thông tin có giá trị để phát hiện sự bất thường. Ví dụ: trong hình dưới đây, người dùng được kết nối thông qua các thực thể dùng chung như ID Wi-Fi, vị trí thực tế và số điện thoại. Do số lượng lớn các giá trị duy nhất của các thực thể này, chẳng hạn như số điện thoại, nên rất khó sử dụng chúng trong các mô hình dựa trên tính năng truyền thống—ví dụ: mã hóa một lần tất cả các số điện thoại sẽ không khả thi. Nhưng những mối quan hệ như vậy có thể giúp dự đoán liệu người dùng có phải là kẻ lừa đảo hay không. Nếu người dùng đã chia sẻ một số thực thể với một kẻ lừa đảo đã biết thì nhiều khả năng người dùng đó là kẻ lừa đảo.

Gần đây, mạng nơ-ron đồ thị (GNN) đã trở thành một phương pháp phổ biến để phát hiện gian lận. Các mô hình GNN có thể kết hợp cả cấu trúc biểu đồ và thuộc tính của các nút hoặc cạnh, chẳng hạn như người dùng hoặc giao dịch, để tìm hiểu các cách biểu diễn có ý nghĩa nhằm phân biệt người dùng và sự kiện độc hại với những sự kiện và người dùng hợp pháp. Khả năng này rất quan trọng để phát hiện các hành vi gian lận, trong đó những kẻ lừa đảo thông đồng để che giấu những đặc điểm bất thường của chúng nhưng để lại một số dấu vết quan hệ.

Các giải pháp GNN hiện tại chủ yếu dựa vào chế độ suy luận và đào tạo hàng loạt ngoại tuyến, giúp phát hiện những kẻ lừa đảo sau khi các sự kiện độc hại xảy ra và tổn thất đã xảy ra. Tuy nhiên, việc nắm bắt những người dùng và hoạt động lừa đảo trong thời gian thực là rất quan trọng để ngăn ngừa tổn thất. Điều này đặc biệt đúng trong các trường hợp kinh doanh khi chỉ có một cơ hội duy nhất để ngăn chặn các hoạt động gian lận. Ví dụ: ở một số nền tảng thương mại điện tử, việc đăng ký tài khoản được mở rộng rãi. Những kẻ lừa đảo có thể hành xử ác ý chỉ một lần với một tài khoản và không bao giờ sử dụng lại tài khoản đó nữa.

Dự đoán những kẻ lừa đảo trong thời gian thực là rất quan trọng. Tuy nhiên, việc xây dựng một giải pháp như vậy là một thách thức. Bởi vì GNN vẫn còn mới đối với ngành nên có rất ít tài nguyên trực tuyến về việc chuyển đổi mô hình GNN từ phân phối hàng loạt sang phân phối theo thời gian thực. Ngoài ra, việc xây dựng một đường truyền dữ liệu truyền trực tuyến có thể cung cấp các sự kiện đến cho API phân phát thời gian thực GNN là một thách thức. Theo hiểu biết tốt nhất của tác giả, không có kiến ​​trúc và ví dụ tham chiếu nào có sẵn cho các giải pháp suy luận thời gian thực dựa trên GNN tính đến thời điểm viết bài này.

Để giúp các nhà phát triển áp dụng GNN vào việc phát hiện gian lận theo thời gian thực, bài đăng này hướng dẫn cách sử dụng Sao Hải vương Amazon, Amazon SageMaker, và Thư viện đồ thị sâu (DGL), cùng với các dịch vụ AWS khác, để xây dựng giải pháp toàn diện nhằm phát hiện gian lận trong thời gian thực bằng mô hình GNN.

Chúng tôi tập trung vào bốn nhiệm vụ:

• Xử lý tập dữ liệu giao dịch dạng bảng thành tập dữ liệu biểu đồ không đồng nhất
• Đào tạo mô hình GNN bằng SageMaker
• Triển khai các mô hình GNN đã được đào tạo làm điểm cuối SageMaker
• Thể hiện suy luận thời gian thực cho các giao dịch đến

Bài đăng này mở rộng công việc trước đó trong Phát hiện gian lận trong các mạng không đồng nhất bằng Amazon SageMaker và Thư viện đồ thị sâu, tập trung vào hai nhiệm vụ đầu tiên. Bạn có thể tham khảo bài đăng đó để biết thêm chi tiết về biểu đồ không đồng nhất, GNN và đào tạo GNN bán giám sát.

Các doanh nghiệp đang tìm kiếm dịch vụ AWS AI được quản lý đầy đủ để phát hiện gian lận cũng có thể sử dụng Phát hiện gian lận Amazon, giúp dễ dàng xác định các hoạt động trực tuyến có khả năng gian lận, chẳng hạn như tạo tài khoản giả hoặc gian lận thanh toán trực tuyến.

Tổng quan về giải pháp

Giải pháp này có hai phần chính.

Phần đầu tiên là một quy trình xử lý dữ liệu, huấn luyện các mô hình GNN và triển khai các mô hình đã huấn luyện. Nó sử dụng Keo AWS để xử lý dữ liệu giao dịch và lưu dữ liệu đã xử lý vào cả hai Sao Hải vương Amazon và Dịch vụ lưu trữ đơn giản của Amazon (Amazon S3). Sau đó, công việc đào tạo SageMaker được kích hoạt để đào tạo mô hình GNN về dữ liệu được lưu trong Amazon S3 nhằm dự đoán liệu một giao dịch có gian lận hay không. Mô hình đã đào tạo cùng với các tài sản khác được lưu lại vào Amazon S3 sau khi hoàn thành công việc đào tạo. Cuối cùng, mô hình đã lưu được triển khai dưới dạng điểm cuối SageMaker. Đường ống được sắp xếp bởi Chức năng bước AWS, như thể hiện trong hình sau.

Phần thứ hai của giải pháp thực hiện phát hiện giao dịch gian lận theo thời gian thực. Nó bắt đầu từ API RESTful truy vấn cơ sở dữ liệu đồ thị trong Neptune để trích xuất đồ thị con liên quan đến giao dịch đến. Nó cũng có một cổng web có thể mô phỏng các hoạt động kinh doanh, tạo ra các giao dịch trực tuyến với cả giao dịch lừa đảo và hợp pháp. Cổng thông tin web cung cấp hình ảnh trực tiếp về việc phát hiện gian lận. Phần này sử dụng Amazon CloudFront, Amplify AWS, Ứng dụng AWS, Cổng API Amazon, Chức năng Bước, và Tài liệu AmazonDB để nhanh chóng xây dựng ứng dụng web. Sơ đồ sau minh họa quá trình suy luận thời gian thực và cổng web.

Việc triển khai giải pháp này cùng với Hình thành đám mây AWS mẫu có thể khởi chạy kiến ​​trúc trong tài khoản AWS của bạn, được cung cấp công khai thông qua các trang sau Repo GitHub.

Xử lí dữ liệu

Trong phần này, chúng tôi mô tả ngắn gọn cách xử lý một tập dữ liệu mẫu và chuyển đổi nó từ các bảng thô thành biểu đồ với các mối quan hệ được xác định giữa các cột khác nhau.

Giải pháp này sử dụng cùng một tập dữ liệu, Bộ dữ liệu gian lận IEEE-CIS, như bài trước Phát hiện gian lận trong các mạng không đồng nhất bằng Amazon SageMaker và Thư viện đồ thị sâu. Vì vậy, nguyên tắc cơ bản của quá trình xử lý dữ liệu là như nhau. Tóm lại, tập dữ liệu gian lận bao gồm bảng giao dịch và bảng nhận dạng, có gần 500,000 hồ sơ giao dịch ẩn danh cùng với thông tin theo ngữ cảnh (ví dụ: thiết bị được sử dụng trong giao dịch). Một số giao dịch có nhãn nhị phân, cho biết giao dịch đó có gian lận hay không. Nhiệm vụ của chúng tôi là dự đoán giao dịch nào không được gắn nhãn là gian lận và giao dịch nào là hợp pháp.

Hình dưới đây minh họa quy trình chung về cách chuyển đổi các bảng IEEE thành biểu đồ không đồng nhất. Đầu tiên chúng tôi trích xuất hai cột từ mỗi bảng. Một cột luôn là cột ID giao dịch, trong đó chúng tôi đặt mỗi ID giao dịch duy nhất làm một nút. Một cột khác được chọn từ các cột phân loại, chẳng hạn như cột ProductCD và id_03, trong đó mỗi danh mục duy nhất được đặt làm một nút. Nếu TransactionID và một danh mục duy nhất xuất hiện trong cùng một hàng, chúng tôi sẽ kết nối chúng với một cạnh. Bằng cách này, chúng tôi chuyển đổi hai cột trong một bảng thành một cột hai bên. Sau đó, chúng tôi kết hợp các nút lưỡng cực đó cùng với các nút TransactionID, trong đó các nút TransactionID giống nhau được hợp nhất thành một nút duy nhất. Sau bước này, chúng ta có một biểu đồ không đồng nhất được xây dựng từ lưỡng cực.

Đối với các cột còn lại không được sử dụng để xây dựng biểu đồ, chúng tôi nối chúng lại với nhau dưới dạng tính năng của các nút TransactionID. Các giá trị TransactionID có giá trị isFraud được sử dụng làm nhãn cho quá trình đào tạo mô hình. Dựa trên biểu đồ không đồng nhất này, nhiệm vụ của chúng ta trở thành nhiệm vụ phân loại nút của các nút TransactionID. Để biết thêm chi tiết về việc chuẩn bị dữ liệu đồ thị cho GNN huấn luyện, hãy tham khảo phần Khai thác tính năng và Xây dựng đồ thị các phần của bài viết blog trước đó.

Mã được sử dụng trong giải pháp này có sẵn trong src/scripts/glue-etl.py. Bạn cũng có thể thử nghiệm xử lý dữ liệu thông qua sổ ghi chép Jupyter src/sagemaker/01.FD_SL_Process_IEEE-CIS_Dataset.ipynb.

Thay vì xử lý dữ liệu theo cách thủ công như đã thực hiện trong bài trước, giải pháp này sử dụng quy trình hoàn toàn tự động được điều phối bởi Step Functions và AWS Glue, hỗ trợ xử lý song song các bộ dữ liệu khổng lồ thông qua Apache Spark. Quy trình làm việc của Step Functions được viết bằng Bộ công cụ phát triển đám mây AWS (AWS CDK). Sau đây là một đoạn mã để tạo quy trình công việc này:

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

Bên cạnh việc xây dựng dữ liệu biểu đồ để đào tạo mô hình GNN, quy trình công việc này còn tải hàng loạt dữ liệu biểu đồ vào Neptune để tiến hành suy luận theo thời gian thực sau này. Quá trình tải dữ liệu hàng loạt này được thể hiện trong đoạn mã sau:

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

Đào tạo mô hình GNN

Sau khi dữ liệu đồ thị để huấn luyện mô hình được lưu vào Amazon S3, một Công việc đào tạo SageMaker, chỉ bị tính phí khi tác vụ đào tạo đang chạy, được kích hoạt để bắt đầu quá trình đào tạo mô hình GNN ở chế độ Mang theo vùng chứa riêng của bạn (BYOC). Nó cho phép bạn đóng gói các tập lệnh đào tạo mô hình và các phần phụ thuộc trong hình ảnh Docker mà nó sử dụng để tạo các phiên bản đào tạo SageMaker. Phương pháp BYOC có thể tiết kiệm đáng kể công sức trong việc thiết lập môi trường đào tạo. TRONG src/sagemaker/02.FD_SL_Build_Training_Container_Test_Local.ipynb, bạn có thể tìm thấy thông tin chi tiết về quá trình đào tạo mô hình GNN.

Hình ảnh Docker

Phần đầu tiên của tệp sổ ghi chép Jupyter là tạo hình ảnh Docker đào tạo (xem đoạn mã sau):

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

Chúng tôi đã sử dụng hình ảnh dựa trên PyTorch để đào tạo mô hình. Thư viện đồ thị sâu (DGL) và các phần phụ thuộc khác được cài đặt khi xây dựng hình ảnh Docker. Mã mô hình GNN trong src/sagemaker/FD_SL_DGL/gnn_fraud_detection_dgl thư mục cũng được sao chép vào hình ảnh.

Bởi vì chúng tôi xử lý dữ liệu giao dịch thành một biểu đồ không đồng nhất nên trong giải pháp này chúng tôi chọn Mạng chuyển đổi đồ thị quan hệ (RGCN), được thiết kế đặc biệt cho các đồ thị không đồng nhất. Mô hình RGCN của chúng tôi có thể huấn luyện các phần nhúng có thể học được cho các nút trong biểu đồ không đồng nhất. Sau đó, các phần nhúng đã học được sử dụng làm đầu vào của lớp được kết nối đầy đủ để dự đoán nhãn nút.

Siêu tham số

Để huấn luyện GNN, chúng ta cần xác định một số siêu tham số trước quá trình huấn luyện, chẳng hạn như tên tệp của biểu đồ được xây dựng, số lớp của mô hình GNN, giai đoạn huấn luyện, trình tối ưu hóa, tham số tối ưu hóa, v.v. Xem đoạn mã sau để biết một tập hợp con các cấu hình:

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}

Để biết thêm thông tin về tất cả các siêu tham số và giá trị mặc định của chúng, hãy xem estimator_fns.py trong src/sagemaker/FD_SL_DGL/gnn_fraud_detection_dgl thư mục.

Đào tạo mô hình với SageMaker

Sau khi hình ảnh Docker vùng chứa tùy chỉnh được tạo, chúng tôi sử dụng dữ liệu được xử lý trước để huấn luyện mô hình GNN với các siêu tham số mà chúng tôi đã xác định. Công việc đào tạo sử dụng DGL, với PyTorch làm khung học sâu phụ trợ, để xây dựng và đào tạo GNN. SageMaker giúp dễ dàng huấn luyện các mô hình GNN bằng hình ảnh Docker tùy chỉnh, đây là đối số đầu vào của công cụ ước tính SageMaker. Để biết thêm thông tin về việc đào tạo GNN bằng DGL trên SageMaker, hãy xem Đào tạo một mạng lưới đồ thị sâu.

SDK Python của SageMaker sử dụng Người định giá để gói gọn chương trình đào tạo về SageMaker, chạy các vùng chứa Docker tùy chỉnh tương thích với SageMaker, cho phép bạn chạy các thuật toán ML của riêng mình bằng cách sử dụng SageMaker Python SDK. Đoạn mã sau đây minh họa việc đào tạo mô hình bằng SageMaker (trong môi trường cục bộ hoặc phiên bản đám mây):

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)

Sau khi huấn luyện, hiệu suất của mô hình GNN trên tập kiểm tra được hiển thị giống như kết quả đầu ra sau. Mô hình RGCN thông thường có thể đạt được khoảng 0.87 AUC và độ chính xác hơn 95%. Để so sánh mô hình RGCN với các mô hình ML khác, hãy tham khảo Kết quả phần của bài viết blog trước để biết thêm chi tiết.

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

Sau khi hoàn thành quá trình đào tạo mô hình, SageMaker đóng gói mô hình đã đào tạo cùng với các nội dung khác, bao gồm cả phần nhúng nút đã đào tạo, vào tệp ZIP rồi tải mô hình đó lên vị trí S3 được chỉ định. Tiếp theo, chúng tôi thảo luận về việc triển khai mô hình đã được đào tạo để phát hiện gian lận theo thời gian thực.

Triển khai mô hình GNN

SageMaker giúp việc triển khai các mô hình ML được đào tạo trở nên đơn giản. Trong giai đoạn này, chúng tôi sử dụng lớp SageMaker PyTorchModel để triển khai mô hình đã đào tạo vì mô hình DGL của chúng tôi phụ thuộc vào PyTorch làm khung phụ trợ. Bạn có thể tìm thấy mã triển khai trong src/sagemaker/03.FD_SL_Endpoint_Deployment.ipynb tập tin.

Bên cạnh nội dung và tệp mô hình đã được đào tạo, SageMaker yêu cầu tệp điểm đầu vào để triển khai mô hình tùy chỉnh. Tệp điểm nhập được chạy và lưu trữ trong bộ nhớ của phiên bản điểm cuối suy luận để đáp ứng yêu cầu suy luận. Trong trường hợp của chúng tôi, tệp điểm vào là fd_sl_deployment_entry_point.py tập tin trong src/sagemaker/FD_SL_DGL/code thư mục, thực hiện bốn chức năng chính:

• Nhận yêu cầu và phân tích nội dung của yêu cầu để có được các nút được dự đoán và dữ liệu liên quan của chúng
• Chuyển đổi dữ liệu thành biểu đồ không đồng nhất DGL làm đầu vào cho mô hình RGCN
• Thực hiện suy luận thời gian thực thông qua mô hình RGCN đã được huấn luyện
• Trả kết quả dự đoán cho người yêu cầu

Theo quy ước của SageMaker, hai chức năng đầu tiên được triển khai trong input_fn phương pháp. Xem đoạn mã sau (để đơn giản, chúng tôi xóa một số mã nhận xét):

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)

Đồ thị DGL được xây dựng và các tính năng sau đó được chuyển đến predict_fn phương pháp thực hiện chức năng thứ ba. predict_fn nhận hai đối số đầu vào: đầu ra của input_fn và mô hình được đào tạo. Xem đoạn mã sau:

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]

Mô hình được sử dụng trong perdict_fn được tạo ra bởi model_fn phương thức khi điểm cuối được gọi lần đầu tiên. Chức năng model_fn tải tệp mô hình đã lưu và các nội dung liên quan từ model_dir đối số và thư mục mô hình SageMaker. Xem đoạn mã sau:

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

Đầu ra của predict_fn phương thức là một danh sách gồm hai số, biểu thị nhật ký của lớp 0 và lớp 1, trong đó 0 có nghĩa là hợp pháp và 1 có nghĩa là lừa đảo. SageMaker lấy danh sách này và chuyển nó tới một phương thức bên trong có tên là output_fn để hoàn thành chức năng cuối cùng.

Để triển khai mô hình GNN, trước tiên, chúng tôi gói mô hình GNN vào lớp SageMaker PyTorchModel với tệp điểm nhập và các tham số khác (đường dẫn của tệp ZIP đã lưu, phiên bản khung PyTorch, phiên bản Python, v.v.). Sau đó, chúng tôi gọi phương thức triển khai của nó bằng các cài đặt phiên bản. Xem đoạn mã sau:

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

Các quy trình và đoạn mã trước đây minh họa cách triển khai mô hình GNN của bạn dưới dạng điểm cuối suy luận trực tuyến từ sổ ghi chép Jupyter. Tuy nhiên, đối với sản xuất, chúng tôi khuyên bạn nên sử dụng quy trình MLOps đã đề cập trước đó do Step Functions sắp xếp cho toàn bộ quy trình làm việc, bao gồm xử lý dữ liệu, đào tạo mô hình và triển khai điểm cuối suy luận. Toàn bộ quy trình được triển khai bởi AWS CDK ứng dụng, có thể dễ dàng sao chép ở các Khu vực và tài khoản khác nhau.

Suy luận thời gian thực

Khi có giao dịch mới đến, để thực hiện dự đoán theo thời gian thực, chúng ta cần hoàn thành bốn bước:

1. Chèn nút và cạnh – Trích xuất thông tin của giao dịch như TransactionID và ProductCD dưới dạng nút và cạnh, đồng thời chèn các nút mới vào dữ liệu biểu đồ hiện có được lưu trữ tại cơ sở dữ liệu Neptune.
2. Trích xuất đồ thị con – Đặt nút giao dịch được dự đoán làm nút trung tâm và trích xuất sơ đồ con n-hop theo yêu cầu đầu vào của mô hình GNN.
3. Khai thác tính năng – Đối với các nút và cạnh trong sơ đồ con, trích xuất các đặc điểm liên quan của chúng.
4. Gọi điểm cuối suy luận – Đóng gói sơ đồ con và các đặc điểm vào nội dung của yêu cầu, sau đó gửi yêu cầu đến điểm cuối suy luận.

Trong giải pháp này, chúng tôi triển khai API RESTful để đạt được khả năng xác định gian lận theo thời gian thực được mô tả ở các bước trước. Xem mã giả sau đây để biết dự đoán theo thời gian thực. Việc thực hiện đầy đủ là trong tập tin mã nguồn hoàn chỉnh.

Để dự đoán theo thời gian thực, ba bước đầu tiên yêu cầu độ trễ thấp hơn. Do đó, cơ sở dữ liệu đồ thị là lựa chọn tối ưu cho các tác vụ này, đặc biệt đối với việc trích xuất đồ thị con, điều này có thể đạt được một cách hiệu quả bằng các truy vấn cơ sở dữ liệu đồ thị. Các hàm gạch chân hỗ trợ mã giả dựa trên các truy vấn gremlin của 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

Một lưu ý về việc phát hiện gian lận theo thời gian thực bằng GNN là chế độ suy luận GNN. Để thực hiện suy luận thời gian thực, chúng ta cần chuyển đổi suy luận mô hình GNN từ chế độ chuyển nạp sang chế độ quy nạp. Các mô hình GNN ở chế độ suy luận chuyển nạp không thể đưa ra dự đoán cho các nút và cạnh mới xuất hiện, trong khi ở chế độ quy nạp, mô hình GNN có thể xử lý các nút và cạnh mới. Một minh họa về sự khác biệt giữa chế độ chuyển đổi và quy nạp được thể hiện trong hình dưới đây.

Ở chế độ chuyển đổi, các nút và cạnh được dự đoán cùng tồn tại với các nút và cạnh được gắn nhãn trong quá trình huấn luyện. Các mô hình xác định chúng trước khi suy luận và chúng có thể được suy ra trong quá trình đào tạo. Các mô hình ở chế độ quy nạp được huấn luyện trên biểu đồ huấn luyện nhưng cần dự đoán các nút không nhìn thấy (các nút trong vòng tròn chấm màu đỏ ở bên phải) với các nút lân cận được liên kết của chúng, có thể là các nút mới, như nút tam giác màu xám ở bên phải.

Mô hình RGCN của chúng tôi được huấn luyện và thử nghiệm ở chế độ chuyển đổi. Nó có quyền truy cập vào tất cả các nút trong quá trình đào tạo và cũng đã đào tạo cách nhúng cho từng nút không có đặc điểm gì, chẳng hạn như địa chỉ IP và loại thẻ. Trong giai đoạn thử nghiệm, mô hình RGCN sử dụng các phần nhúng này làm tính năng nút để dự đoán các nút trong tập thử nghiệm. Tuy nhiên, khi chúng tôi thực hiện suy luận theo thời gian thực, một số nút không có chức năng mới được thêm vào không có phần nhúng như vậy vì chúng không có trong biểu đồ huấn luyện. Một cách để giải quyết vấn đề này là gán giá trị trung bình của tất cả các phần nhúng trong cùng loại nút cho các nút mới. Trong giải pháp này, chúng tôi áp dụng phương pháp này.

Ngoài ra, giải pháp này còn cung cấp một cổng web (như trong ảnh chụp màn hình sau) để chứng minh các dự đoán gian lận theo thời gian thực từ quan điểm của các nhà điều hành kinh doanh. Nó có thể tạo ra các giao dịch trực tuyến mô phỏng và cung cấp hình ảnh trực tiếp về thông tin giao dịch gian lận được phát hiện.

Làm sạch

Khi bạn khám phá xong giải pháp, bạn có thể làm sạch tài nguyên để tránh phát sinh phí.

Kết luận

Trong bài đăng này, chúng tôi đã trình bày cách xây dựng giải pháp phát hiện gian lận theo thời gian thực dựa trên GNN bằng SageMaker, Neptune và DGL. Giải pháp này có ba ưu điểm chính:

• Nó có hiệu suất tốt về độ chính xác dự đoán và số liệu AUC
• Nó có thể thực hiện suy luận theo thời gian thực thông qua đường dẫn MLOps phát trực tuyến và điểm cuối SageMaker
• Nó tự động hóa toàn bộ quá trình triển khai với mẫu CloudFormation được cung cấp để các nhà phát triển quan tâm có thể dễ dàng thử nghiệm giải pháp này bằng dữ liệu tùy chỉnh trong tài khoản của họ

Để biết thêm chi tiết về giải pháp, hãy xem Repo GitHub.

Sau khi triển khai giải pháp này, chúng tôi khuyên bạn nên tùy chỉnh mã xử lý dữ liệu để phù hợp với định dạng dữ liệu của riêng bạn và sửa đổi cơ chế suy luận thời gian thực trong khi vẫn giữ nguyên mô hình GNN. Lưu ý rằng chúng tôi chia suy luận thời gian thực thành bốn bước mà không tối ưu hóa thêm độ trễ. Bốn bước này mất vài giây để có được dự đoán về tập dữ liệu demo. Chúng tôi tin rằng việc tối ưu hóa thiết kế lược đồ dữ liệu biểu đồ Neptune và các truy vấn để trích xuất biểu đồ con và tính năng có thể giảm đáng kể độ trễ suy luận.

Giới thiệu về tác giả

Kiến Trương là một nhà khoa học ứng dụng, người đã sử dụng các kỹ thuật máy học để giúp khách hàng giải quyết nhiều vấn đề khác nhau, chẳng hạn như phát hiện gian lận, tạo hình ảnh trang trí, v.v. Anh đã phát triển thành công máy học dựa trên đồ thị, đặc biệt là mạng lưới thần kinh đồ thị, các giải pháp cho khách hàng tại Trung Quốc, Mỹ và Singapore. Với tư cách là người khai sáng các khả năng đồ thị của AWS, Zhang đã có nhiều bài thuyết trình trước công chúng về GNN, Thư viện đồ thị sâu (DGL), Amazon Neptune và các dịch vụ AWS khác.

Mạnh Tân Chu là người quản lý Kiến trúc sư giải pháp tại AWS, tập trung vào việc thiết kế và phát triển các giải pháp AWS có thể tái sử dụng. Ông đã tham gia phát triển phần mềm trong nhiều năm và chịu trách nhiệm cho một số nhóm khởi nghiệp thuộc nhiều quy mô khác nhau. Ông cũng là người ủng hộ phần mềm nguồn mở và là Người cam kết Eclipse.

Hạo Châu Vương là nhà khoa học nghiên cứu tại Phòng thí nghiệm giải pháp máy học Amazon, nơi ông đồng lãnh đạo Nhóm Học tập tăng cường. Anh giúp khách hàng xây dựng các giải pháp máy học tiên tiến bằng các nghiên cứu mới nhất về học bằng đồ thị, xử lý ngôn ngữ tự nhiên, học tăng cường và AutoML. Haozhu nhận bằng Tiến sĩ về Kỹ thuật Điện và Máy tính tại Đại học Michigan.