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 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 Google Cloud AI Platform.

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 một dự á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 BigQuery

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 Google Cloud.

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. Điều hướng qua các tập dữ liệu có sẵn cho đến khi bạn tìm thấy ml-datasets, sau đó chọn bảng ulb-fraud-detection trong đó:

d5e78261514a90ef.png

Nhấp vào mỗi 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 là gian lận.
  • Thẻ Xem trước cho thấy các bản ghi từ tập dữ liệu.

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

Thẻ chi tiết cho chúng tôi biết 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 điểm giao dịch đã chọn.
  • Phiên bản 1–V28 là các cột đã được chuyển đổi thông qua kỹ thuật giảm kích thước gọi là PCA. Kỹ thuật này đã ẩ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 truy vấn:

581e596426a98383.pngS

Cập nhật câu lệnh để thêm dấu * để 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 cùng xem qua mối tương quan giữa dữ liệu với biến mục tiêu Class (Lớp).

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`

e1e98a8315b62e9e.png

Tương quan sẽ cung cấp một phạm vi từ -1 (tương quan âm) đến 1 (tương quan dương), với 0 là độc lập.

Xin lưu ý rằng V1 và V1 có mối tương quan nhỏ với biến mục tiêu (tương ứng vào khoảng -0,1 và ,1).

Chúng tôi không thấy có nhiều mối tương quan với Thời gian. Mối tương quan hơi tiêu cực có thể cho chúng tôi 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 thậm chí còn có mối tương quan thấp hơn, cho thấy rằng các giao dịch gian lận có rất ít khả năng có số tiền giao dịch cao hơn.

Bước 4: Tính giá trị trung bình cho tỷ lệ tính năng

Chuẩn hoá các giá trị của tính năng có thể giúp mạng nơron hội tụ nhanh hơn. Một sơ đồ phổ biến là căn giữa các giá trị 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 phải 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 bao gồm một mệnh đề WHERE thú vị. Chúng tôi sẽ mô tả điều đó trong phần tiếp theo, khi chúng tôi đề cập đến cách phân chia dữ liệu giữa tập huấn luyện và tập kiểm thử.

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

Thông thường, 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: dùng để xây dựng mô hình bằng cách điều chỉnh lặp lại các tham số
  • Xác thực: dùng để đánh giá xem mô hình có phù hợp 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 sử 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 phần phân tách huấn luyện/xác thực/kiểm thử 80/10/10.

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

1084d9f5edbf760b.pngS

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ử.

e5b8646ebdf5f272.png

Bây giờ, chúng ta sẽ chạy 3 truy vấn để huấn luyện, kiểm tra và 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 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 bảng BigQuery.

49d20c9b4b62f6a7.pngS

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.

6d83cf113a0682e1.png.

Trước tiên, mệnh đề WHERE phân tách dữ liệu bằng cách tính toán hàm băm trên một vài cột. Sau đó, nó chọn các hàng mà phần còn lại của hàm băm khi chia cho 10 là dưới 80, mang lại cho chúng ta 80%.

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

Xác nhận kết quả

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 Sổ tay

Chúng ta đã giới thiệu ngắn gọn về dữ liệu, bây giờ 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ếu API đó đang tắt.

9895a2fd3cdf8f8c.png.

Bước 2: Tạo một thực thể Sổ tay nền tảng AI

Chuyển đến mục Sổ tay trên nền tảng AI trên Cloud Console rồi nhấp vào Phiên bản mới. Sau đó, hãy chọn loại thực thể TensorFlow Enterprise 1.x mới nhất không có GPU:

35301141e9fd3f44.pngs

Sử dụng các tuỳ 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:

3b801f8ff3db0f2f.png.

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

58523671a252b95a.pngS

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

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

Trong ô đầu tiên của sổ tay, hãy thêm các lệnh nhập sau đây và chạy ô. Bạn có thể chạy trình đơn 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 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: Định nghĩa 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 tiếp tục và 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 hàm trợ giúp

Bây giờ, hãy xác định một vài hàm. read_session() đọc dữ liệu 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, sao cho tập dữ liệu có định dạng mà extract_labels() dự kiến 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. 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 việc 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. Mô hình bản dựng

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

Hãy tạo các cột đối tượng cho mỗi đố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 số_cột,nhưng có một số loại cột khác (ví dụ: cột_phân_loại).

Như đã thảo luận trước đó, chúng ta cũng sẽ chuẩn bị dữ liệu tập trung về khoảng 0 để mạng hội tụ nhanh hơn. Chúng tôi đã tính trước giá trị trung bình của từng tính năng để 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: Xây dựng mô hình

Bây giờ, chúng ta đã sẵn sàng để tạo mô hình. Chúng tôi 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 thêm chỉ số AUC chính xác/thu hồi. Chỉ số này hữu ích đối với 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: Đào tạo mô hình

Có một số kỹ thuật để xử lý dữ liệu mất 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à giảm tần số lấy mẫu (giảm dữ liệu trong lớp đa số).

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

Chúng ta sẽ sử dụng 3 khoảng thời gian bắt đầu của hệ thống (truyền qua dữ liệu) trong phòng thí nghiệm này để việc huấn luyện diễn ra nhanh hơn. Trong tình huống thực tế, chúng ta muốn chạy chiến dịch đủ lâu để đạt đến mức độ chính xác của tập hợp xác thực sẽ tăng lên.

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 đánh giá() 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 đã đặt dữ liệu thử nghiệm sang một bên!

model.evaluate(test_data)

Bước 5: Khám phá

Trong phòng thí nghiệm này, chúng tôi đã chứng minh cách nhập trực tiếp một tập dữ liệu lớn từ BigQuery vào mô hình TensorFlow Keras. Chúng ta cũng đã tìm hiểu tất cả các bước xây dựng một 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 cấu trúc và phương pháp đối với tập dữ liệu bất 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 sử dụng. Trên giao diện người dùng của Sổ tay trong Cloud Console, hãy chọn sổ tay đó rồi chọn Dừng:

57213ef2edad9257.pngS

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

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