Xây dựng mô hình Phát hiện gian lận trên Cloud AI Platform bằng TensorFlow Enterprise và BigQuery

1. Tổng quan

Trong phòng thí nghiệm này, bạn sẽ trực tiếp nhập một tập dữ liệu BigQuery và huấn luyện một mô hình phát hiện gian lận bằng TensorFlow Enterprise trên Nền tảng Trí tuệ nhân tạo của Google Cloud.

Kiến thức bạn sẽ học được

Bạn sẽ tìm hiểu cách:

• Phân tích dữ liệu trên BigQuery
• Nhập dữ liệu bằng trình kết nối BigQuery trong TensorFlow Enterprise
• Xây dựng mô hình học sâu để phát hiện hành vi gian lận bằng một tập dữ liệu không cân bằng

2. Phân tích dữ liệu trong BigQuery

Bạn cần có một dự án trên Google Cloud Platform đã bật tính năng thanh toán để chạy lớp học lập trình này. Để tạo một dự án, hãy làm theo hướng dẫn tại đây.

Bước 1: Truy cập vào tập dữ liệu công khai của BigQuery

Hãy truy cập vào đường liên kết này để truy cập vào các tập dữ liệu công khai của BigQuery trong bảng điều khiển Cloud của Google.

Trong Cây tài nguyên ở góc dưới cùng bên trái, bạn sẽ thấy danh sách các tập dữ liệu. Duyệt qua các tập dữ liệu có sẵn cho đến khi bạn tìm thấy ml-datasets, rồi chọn bảng ulb-fraud-detection trong tập dữ liệu đó:

Nhấp vào từng thẻ để tìm hiểu thêm về tập dữ liệu:

• Thẻ Giản đồ mô tả các loại dữ liệu.
• Thẻ Chi tiết giải thích rằng đây là một tập dữ liệu không cân bằng với 284.407 giao dịch, trong đó có 492 giao dịch gian lận.
• Thẻ Xem trước cho thấy các bản ghi trong tập dữ liệu.

Bước 2: Truy vấn Bảng

Thẻ chi tiết cho chúng ta biết những thông tin sau về dữ liệu:

• Thời gian là số giây giữa giao dịch đầu tiên trong tập dữ liệu và thời gian của giao dịch đã chọn.
• V1 – V28 là các cột đã được chuyển đổi thông qua một kỹ thuật giảm chiều được gọi là PCA giúp ẩn danh dữ liệu.
• Số tiền là số tiền giao dịch.

Hãy xem xét kỹ hơn bằng cách nhấp vào Bảng truy vấn để chạy một truy vấn:

Cập nhật câu lệnh để thêm dấu * nhằm xem tất cả các cột, rồi nhấp vào Chạy.

SELECT * FROM `bigquery-public-data.ml_datasets.ulb_fraud_detection` LIMIT 1000

Bước 3: Phân tích dữ liệu

BigQuery cung cấp một số hàm thống kê. Hãy xem xét cách dữ liệu tương quan với biến mục tiêu Class.

SELECT CORR(Time,Class) as TimeCorr, CORR(V1,Class) as V1Corr, CORR(V2,Class) as V2Corr, CORR(Amount,Class) as AmountCorr FROM `bigquery-public-data.ml_datasets.ulb_fraud_detection`

Mức độ tương quan sẽ nằm trong khoảng từ -1 (tương quan nghịch) đến 1 (tương quan thuận), với 0 là độc lập.

Xin lưu ý rằng V1 và V2 có mối tương quan nhỏ với biến mục tiêu của chúng tôi (lần lượt là khoảng -0,1 và 0,1).

Chúng tôi không thấy nhiều mối tương quan với Thời gian. Mối tương quan âm nhẹ có thể cho biết rằng có ít giao dịch gian lận hơn theo thời gian trong tập dữ liệu.

Số tiền có mối tương quan thấp hơn nữa, cho thấy rằng các giao dịch gian lận có khả năng xảy ra cao hơn một chút đối với các giao dịch có số tiền cao hơn.

Bước 4: Tính giá trị trung bình để điều chỉnh tỷ lệ của đối tượng

Chuẩn hoá các giá trị của đối tượng có thể giúp mạng nơ-ron hội tụ nhanh hơn. Một lược đồ phổ biến là tập trung các giá trị xung quanh 0 với độ lệch chuẩn là 1. Truy vấn sau đây sẽ truy xuất các giá trị trung bình. Bạn không cần lưu kết quả vì chúng ta sẽ có một đoạn mã cho việc đó sau.

Bạn cũng sẽ nhận thấy rằng truy vấn này có một mệnh đề WHERE thú vị. Chúng ta sẽ mô tả điều đó trong phần tiếp theo, khi tìm hiểu cách chia dữ liệu giữa các tập huấn luyện và tập kiểm định.

SELECT
   AVG(Time), AVG(V1), AVG(V2), AVG(V3), AVG(V4), AVG(V5), AVG(V6), AVG(V7), AVG(V8),
   AVG(V9), AVG(V10),AVG(V11), AVG(V12), AVG(V13), AVG(V14), AVG(V15), AVG(V16),
   AVG(V17), AVG(V18), AVG(V19), AVG(V20), AVG(V21), AVG(V22), AVG(V23), AVG(V24),
   AVG(V25), AVG(V26), AVG(V27),AVG(V28), AVG(Amount)
FROM
   `bigquery-public-data.ml_datasets.ulb_fraud_detection`
WHERE
   MOD(ABS(FARM_FINGERPRINT(CONCAT(SAFE_CAST(Time AS STRING),
   SAFE_CAST(Amount AS STRING)))),10) < 8

Bước 5: Chia tách dữ liệu

Bạn nên sử dụng 3 tập dữ liệu khi xây dựng mô hình học máy:

• Huấn luyện: được dùng để tạo mô hình bằng cách điều chỉnh các tham số theo cách lặp đi lặp lại
• Xác thực: được dùng để đánh giá xem mô hình có đang điều chỉnh quá mức hay không bằng cách xác minh trên dữ liệu độc lập trong quá trình huấn luyện
• Kiểm thử: được dùng sau khi mô hình được tạo để đánh giá độ chính xác

Trong lớp học lập trình này, chúng ta sẽ sử dụng tỷ lệ phân chia 80/10/10 cho tập huấn luyện/xác thực/kiểm thử.

Chúng tôi sẽ đặt mỗi tập dữ liệu vào một bảng riêng trong BigQuery. Bước đầu tiên là tạo một "tập dữ liệu" BigQuery – đây là một vùng chứa cho các bảng có liên quan. Khi dự án của bạn được chọn, hãy chọn Tạo tập dữ liệu.

Sau đó, hãy tạo một tập dữ liệu có tên là tfe_codelab để chứa các bảng huấn luyện, xác thực và kiểm thử.

Bây giờ, chúng ta sẽ chạy 3 truy vấn cho tập huấn luyện, tập kiểm thử và tập xác thực, đồng thời lưu dữ liệu trong tập dữ liệu tfe_codelab mới.

Trong Trình chỉnh sửa truy vấn, hãy chạy một truy vấn để tạo dữ liệu huấn luyện:

SELECT *
FROM `bigquery-public-data.ml_datasets.ulb_fraud_detection`
WHERE MOD(ABS(FARM_FINGERPRINT(CONCAT(SAFE_CAST(Time AS STRING),SAFE_CAST(Amount AS STRING)))),10) < 8

Khi truy vấn hoàn tất, hãy lưu kết quả vào một bảng BigQuery.

Trong tập dữ liệu tfe_codelab mà bạn vừa tạo, hãy đặt tên cho bảng là ulb_fraud_detection_train rồi lưu dữ liệu.

Mệnh đề WHERE trước tiên sẽ phân chia dữ liệu bằng cách tính toán hàm băm trên một số cột. Sau đó, nó sẽ chọn những hàng có số dư của hàm băm khi chia cho 10 nhỏ hơn 80, tức là 80%.

Bây giờ, hãy lặp lại quy trình tương tự cho các tập hợp xác thực và kiểm thử bằng các truy vấn tương tự, mỗi truy vấn chọn 10% dữ liệu.

Xác thực

SELECT *
FROM `bigquery-public-data.ml_datasets.ulb_fraud_detection`
WHERE MOD(ABS(FARM_FINGERPRINT(CONCAT(SAFE_CAST(Time AS STRING),SAFE_CAST(Amount AS STRING)))),10) = 8

Lưu kết quả của truy vấn này vào một bảng có tên là ulb_fraud_detection_val.

Kiểm thử

SELECT *
FROM `bigquery-public-data.ml_datasets.ulb_fraud_detection`
WHERE MOD(ABS(FARM_FINGERPRINT(CONCAT(SAFE_CAST(Time AS STRING),SAFE_CAST(Amount AS STRING)))),10) = 9

Lưu kết quả của truy vấn này vào một bảng có tên là ulb_fraud_detection_test.

3. Thiết lập môi trường Notebook

Bây giờ chúng ta đã xem qua phần giới thiệu ngắn gọn về dữ liệu, hãy thiết lập môi trường phát triển mô hình.

Bước 1: Bật API

Trình kết nối BigQuery sử dụng BigQuery Storage API. Tìm BigQuery Storage API trong bảng điều khiển rồi bật API này nếu hiện đang tắt.

Bước 2: Tạo một phiên bản AI Platform Notebooks

Chuyển đến mục AI Platform Notebooks của bảng điều khiển Cloud rồi nhấp vào New Instance (Phiên bản mới). Sau đó, hãy chọn loại phiên bản TensorFlow Enterprise 1.x mới nhất không có GPU:

Sử dụng các lựa chọn mặc định rồi nhấp vào Tạo. Sau khi tạo phiên bản, hãy chọn Open JupyterLab (Mở JupyterLab):

Sau đó, hãy tạo một sổ tay Python 3 trong JupyterLab:

4. Nhập bản ghi từ BigQuery

Bước 1: Nhập các gói Python

Trong phần còn lại của lớp học lập trình này, hãy chạy tất cả đoạn mã trong sổ tay Jupyter.

Trong ô đầu tiên của sổ tay, hãy thêm các mục nhập sau và chạy ô. Bạn có thể kích hoạt lệnh này bằng cách nhấn nút mũi tên phải trong trình đơn trên cùng hoặc nhấn tổ hợp phím command-enter:

import tensorflow as tf
import tensorflow.keras as keras
import tensorflow.keras.layers as layers

from tensorflow_io.bigquery import BigQueryClient

import functools

tf.enable_eager_execution()

Bước 2: Xác định hằng số

Tiếp theo, hãy xác định một số hằng số để sử dụng trong dự án. Thay đổi GCP_PROJECT_ID thành mã dự án thực tế mà bạn đang sử dụng. Hãy chạy các ô mới khi bạn tạo chúng.

GCP_PROJECT_ID = '<YOUR_PROJECT_ID>'
DATASET_GCP_PROJECT_ID = GCP_PROJECT_ID # A copy of the data is saved in the user project
DATASET_ID = 'tfe_codelab'
TRAIN_TABLE_ID = 'ulb_fraud_detection_train'
VAL_TABLE_ID = 'ulb_fraud_detection_val'
TEST_TABLE_ID = 'ulb_fraud_detection_test'

FEATURES = ['Time','V1','V2','V3','V4','V5','V6','V7','V8','V9','V10','V11','V12','V13','V14','V15','V16','V17','V18','V19','V20','V21','V22','V23','V24','V25','V26','V27','V28','Amount']
LABEL='Class'
DTYPES=[tf.float64] * len(FEATURES) + [tf.int64]

Bước 3: Xác định các hàm trợ giúp

Bây giờ, hãy xác định một số hàm. read_session() đọc dữ liệu từ một bảng BigQuery. extract_labels() là một hàm trợ giúp để tách cột nhãn khỏi phần còn lại, để tập dữ liệu ở định dạng mà keras.model_fit() dự kiến sẽ có sau này.

client = BigQueryClient()

def read_session(TABLE_ID):
    return client.read_session(
        "projects/" + GCP_PROJECT_ID, DATASET_GCP_PROJECT_ID, TABLE_ID, DATASET_ID,
        FEATURES + [LABEL], DTYPES, requested_streams=2
)

def extract_labels(input_dict):
  features = dict(input_dict)
  label = tf.cast(features.pop(LABEL), tf.float64)
  return (features, label)

Bước 4: Nhập dữ liệu

Cuối cùng, hãy tạo từng tập dữ liệu rồi in lô đầu tiên từ tập dữ liệu huấn luyện. Xin lưu ý rằng chúng ta đã xác định BATCH_SIZE là 32. Đây là một tham số quan trọng sẽ ảnh hưởng đến tốc độ và độ chính xác của quá trình huấn luyện.

BATCH_SIZE = 32

raw_train_data = read_session(TRAIN_TABLE_ID).parallel_read_rows().map(extract_labels).batch(BATCH_SIZE)
raw_val_data = read_session(VAL_TABLE_ID).parallel_read_rows().map(extract_labels).batch(BATCH_SIZE)
raw_test_data = read_session(TEST_TABLE_ID).parallel_read_rows().map(extract_labels).batch(BATCH_SIZE)

next(iter(raw_train_data)) # Print first batch

5. Xây dựng mô hình

Bước 1: Xử lý trước dữ liệu

Hãy tạo các cột đối tượng cho từng đối tượng trong tập dữ liệu. Trong tập dữ liệu cụ thể này, tất cả các cột đều thuộc loại numeric_column,nhưng có một số loại cột khác (ví dụ: categorical_column).

Như đã thảo luận trước đó, chúng ta cũng sẽ chuẩn hoá dữ liệu để tập trung vào số 0, nhờ đó mạng lưới sẽ hội tụ nhanh hơn. Chúng tôi đã tính toán trước giá trị trung bình của từng đặc điểm để sử dụng trong phép tính này.

MEANS = [94816.7387536405, 0.0011219465482001268, -0.0021445914636999603, -0.002317402958335562,
         -0.002525792169927835, -0.002136576923287782, -3.7586818983702984, 8.135919975738768E-4,
         -0.0015535579268265718, 0.001436137140461279, -0.0012193712736681508, -4.5364970422902533E-4,
         -4.6175444671576083E-4, 9.92177789685366E-4, 0.002366229151475428, 6.710217226762278E-4,
         0.0010325807119864225, 2.557260815835395E-4, -2.0804190062322664E-4, -5.057391100818653E-4,
         -3.452114767842334E-6, 1.0145936326270006E-4, 3.839214074518535E-4, 2.2061197469126577E-4,
         -1.5601580596677608E-4, -8.235017846415852E-4, -7.298316615408554E-4, -6.898459943652376E-5,
         4.724125688297753E-5, 88.73235686453587]

def norm_data(mean, data):
  data = tf.cast(data, tf.float32) * 1/(2*mean)
  return tf.reshape(data, [-1, 1])

numeric_columns = []

for i, feature in enumerate(FEATURES):
  num_col = tf.feature_column.numeric_column(feature, normalizer_fn=functools.partial(norm_data, MEANS[i]))
  numeric_columns.append(num_col)

numeric_columns

Bước 2: Tạo mô hình

Giờ đây, chúng ta đã sẵn sàng tạo một mô hình. Chúng ta sẽ đưa các cột vừa tạo vào mạng. Sau đó, chúng ta sẽ biên dịch mô hình. Chúng tôi đang đưa vào chỉ số AUC về Độ chính xác/Khả năng thu hồi, hữu ích cho các tập dữ liệu không cân bằng.

model = keras.Sequential([
    tf.keras.layers.DenseFeatures(numeric_columns),
    layers.Dense(64, activation='relu'),
    layers.Dense(64, activation='relu'),
    layers.Dense(1, activation='sigmoid')
])

model.compile(loss='binary_crossentropy',
              optimizer='adam',
              metrics=['accuracy', tf.keras.metrics.AUC(curve='PR')])

Bước 3: Huấn luyện mô hình

Có một số kỹ thuật để xử lý dữ liệu không cân bằng, bao gồm lấy mẫu quá mức (tạo dữ liệu mới trong lớp thiểu số) và lấy mẫu dưới mức (giảm dữ liệu trong lớp đa số).

Trong phạm vi của lớp học lập trình này, hãy sử dụng một kỹ thuật làm tăng trọng số của tổn thất khi phân loại sai lớp thiểu số. Chúng ta sẽ chỉ định một tham số class_weight khi huấn luyện và tăng trọng số "1" (gian lận) vì tham số này ít phổ biến hơn nhiều.

Chúng ta sẽ sử dụng 3 epoch (số lần truyền dữ liệu) trong phòng thí nghiệm này để quá trình huấn luyện diễn ra nhanh hơn. Trong trường hợp thực tế, chúng ta muốn kích hoạt nó đủ lâu cho đến khi không còn thấy độ chính xác của tập xác nhận tăng lên nữa.

CLASS_WEIGHT = {
    0: 1,
    1: 100
}
EPOCHS = 3

train_data = raw_train_data.shuffle(10000)
val_data = raw_val_data
test_data = raw_test_data

model.fit(train_data, validation_data=val_data, class_weight=CLASS_WEIGHT, epochs=EPOCHS)

Bước 4: Đánh giá mô hình

Bạn có thể áp dụng hàm evaluate() cho dữ liệu kiểm thử mà mô hình chưa từng thấy để đưa ra đánh giá khách quan. Rất may là chúng tôi đã dành riêng dữ liệu kiểm thử cho mục đích đó!

model.evaluate(test_data)

Bước 5: Khám phá

Trong phòng thí nghiệm này, chúng tôi đã minh hoạ cách nhập một tập dữ liệu lớn từ BigQuery trực tiếp vào một mô hình TensorFlow Keras. Chúng tôi cũng đã hướng dẫn tất cả các bước xây dựng mô hình. Cuối cùng, chúng ta đã tìm hiểu một chút về cách xử lý các vấn đề phân loại không cân bằng.

Bạn có thể tiếp tục thử nghiệm nhiều kiến trúc và phương pháp khác nhau cho tập dữ liệu không cân bằng để xem liệu bạn có thể cải thiện độ chính xác hay không!

6. Dọn dẹp

Nếu muốn tiếp tục sử dụng sổ tay này, bạn nên tắt sổ tay khi không dùng. Trong giao diện người dùng Notebooks của Cloud Console, hãy chọn sổ tay rồi chọn Dừng:

Nếu bạn muốn xoá tất cả tài nguyên đã tạo trong phòng thí nghiệm này, chỉ cần Xoá phiên bản sổ tay thay vì dừng phiên bản đó.

Sử dụng trình đơn Điều hướng trong Cloud Console, duyệt tìm Storage rồi xoá cả hai vùng chứa mà bạn đã tạo để lưu trữ các thành phần mô hình.