สร้างโมเดลการตรวจจับการฉ้อโกงบน Cloud AI Platform ด้วย TensorFlow Enterprise และ BigQuery

1. ภาพรวม

ใน Lab นี้ คุณจะนำเข้าชุดข้อมูล BigQuery โดยตรงและฝึกโมเดลการตรวจหาการประพฤติมิชอบด้วย TensorFlow Enterprise ใน AI Platform ของ Google Cloud

สิ่งที่คุณจะได้เรียนรู้

โดยคุณจะได้เรียนรู้วิธีต่อไปนี้

วิเคราะห์ข้อมูลใน BigQuery
นำเข้าข้อมูลโดยใช้เครื่องมือเชื่อมต่อ BigQuery ใน TensorFlow Enterprise
สร้างโมเดลการเรียนรู้เชิงลึกเพื่อตรวจจับการประพฤติมิชอบด้วยชุดข้อมูลที่ไม่สมดุล

2. วิเคราะห์ข้อมูลใน BigQuery

คุณจะต้องมีโปรเจ็กต์ Google Cloud Platform ที่เปิดใช้การเรียกเก็บเงินเพื่อเรียกใช้ Codelab นี้ หากต้องการสร้างโปรเจ็กต์ ให้ทำตามวิธีการที่นี่

ขั้นตอนที่ 1: เข้าถึงชุดข้อมูลสาธารณะของ BigQuery

ทําตามลิงก์นี้เพื่อเข้าถึงชุดข้อมูลสาธารณะของ BigQuery ในคอนโซล Google Cloud

คุณจะเห็นรายการชุดข้อมูลในโครงสร้างทรัพยากรที่มุมซ้ายล่าง เลื่อนดูชุดข้อมูลที่มีอยู่จนกว่าจะพบ ml-datasets แล้วเลือกตาราง ulb-fraud-detection ภายในชุดข้อมูลนั้น

คลิกแท็บต่างๆ เพื่อดูข้อมูลเพิ่มเติมเกี่ยวกับชุดข้อมูล

แท็บสคีมาจะอธิบายประเภทข้อมูล
แท็บรายละเอียดอธิบายว่านี่คือชุดข้อมูลที่ไม่สมดุลซึ่งมีธุรกรรม 284,407 รายการ โดยมีธุรกรรมที่เป็นการประพฤติมิชอบ 492 รายการ
แท็บตัวอย่างจะแสดงระเบียนจากชุดข้อมูล

ขั้นตอนที่ 2: ค้นหาในตาราง

แท็บรายละเอียดจะบอกข้อมูลต่อไปนี้เกี่ยวกับข้อมูล

เวลาคือจำนวนวินาทีระหว่างธุรกรรมแรกในชุดข้อมูลกับเวลาของธุรกรรมที่เลือก
V1-V28 คือคอลัมน์ที่ได้รับการแปลงผ่านเทคนิคการลดมิติที่เรียกว่า PCA ซึ่งทําให้ข้อมูลไม่ระบุตัวบุคคล
จำนวนเงินคือจำนวนเงินของธุรกรรม

มาดูรายละเอียดกันโดยคลิกตารางการค้นหาเพื่อเรียกใช้การค้นหา

อัปเดตคำสั่งเพื่อเพิ่ม * เพื่อดูคอลัมน์ทั้งหมด แล้วคลิกเรียกใช้

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

ขั้นตอนที่ 3: วิเคราะห์ข้อมูล

BigQuery มีฟังก์ชันทางสถิติอยู่หลายฟังก์ชัน มาดูว่าข้อมูลมีความสัมพันธ์กับตัวแปรเป้าหมาย 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`

สหสัมพันธ์จะมีช่วงตั้งแต่ -1 (สหสัมพันธ์ทางลบ) ถึง 1 (สหสัมพันธ์ทางบวก) โดย 0 คือไม่มีความสัมพันธ์

โปรดทราบว่า V1 และ V2 มีความสัมพันธ์เล็กน้อยกับตัวแปรเป้าหมาย (ประมาณ -0.1 และ 0.1 ตามลำดับ)

เราไม่พบความสัมพันธ์มากนักกับเวลา สหสัมพันธ์เชิงลบเล็กน้อยอาจบอกเราว่ามีธุรกรรมที่ฉ้อโกงน้อยลงเมื่อเวลาผ่านไปในชุดข้อมูล

จำนวนเงินมีความสัมพันธ์ต่ำกว่า ซึ่งบ่งชี้ว่าธุรกรรมที่ฉ้อโกงมีแนวโน้มที่จะเกิดขึ้นเล็กน้อยในจำนวนเงินธุรกรรมที่สูงกว่า

ขั้นตอนที่ 4: คำนวณค่าเฉลี่ยสำหรับการปรับขนาดฟีเจอร์

การปรับค่าฟีเจอร์ให้เป็นค่าปกติจะช่วยให้โครงข่ายประสาทเทียมบรรจบกันได้เร็วขึ้น รูปแบบทั่วไปคือการจัดค่าให้อยู่ตรงกลางรอบๆ 0 โดยมีค่าเบี่ยงเบนมาตรฐานเป็น 1 คําค้นหาต่อไปนี้จะดึงค่าเฉลี่ย คุณไม่จำเป็นต้องบันทึกผลลัพธ์ เนื่องจากเราจะมีข้อมูลโค้ดสำหรับดำเนินการดังกล่าวในภายหลัง

นอกจากนี้ คุณจะเห็นว่าคําค้นหามีคําสั่ง WHERE ที่น่าสนใจด้วย เราจะอธิบายเรื่องนี้ในส่วนถัดไปเมื่อพูดถึงวิธีแยกข้อมูลระหว่างชุดการฝึกและชุดการทดสอบ

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

ขั้นตอนที่ 5: แยกข้อมูล

โดยทั่วไปจะใช้ชุดข้อมูล 3 ชุดเมื่อสร้างโมเดลแมชชีนเลิร์นนิง

การฝึก: ใช้เพื่อสร้างโมเดลโดยการปรับพารามิเตอร์ซ้ำๆ
การตรวจสอบ: ใช้เพื่อประเมินว่าโมเดลมีความพอดีมากเกินไปหรือไม่โดยการตรวจสอบข้อมูลอิสระในระหว่างกระบวนการฝึก
ทดสอบ: ใช้หลังจากสร้างโมเดลเพื่อประเมินความแม่นยำ

ใน Codelab นี้ เราจะใช้การแยกการฝึก/การตรวจสอบ/การทดสอบเป็น 80/10/10

เราจะใส่ชุดข้อมูลแต่ละชุดลงในตารางของตัวเองใน BigQuery ขั้นตอนแรกคือการสร้าง "ชุดข้อมูล" BigQuery ซึ่งเป็นคอนเทนเนอร์สำหรับตารางที่เกี่ยวข้อง เมื่อเลือกโปรเจ็กต์แล้ว ให้เลือกสร้างชุดข้อมูล

จากนั้นสร้างชุดข้อมูลชื่อ tfe_codelab เพื่อเก็บตารางการฝึก การตรวจสอบ และการทดสอบ

ตอนนี้เราจะเรียกใช้การค้นหา 3 รายการสำหรับการฝึก การทดสอบ และการตรวจสอบความถูกต้อง แล้วบันทึกข้อมูลภายในชุดข้อมูล tfe_codelab ใหม่

ในตัวแก้ไขคำค้นหา ให้เรียกใช้คำค้นหาเพื่อสร้างข้อมูลการฝึก

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

เมื่อการค้นหาเสร็จสมบูรณ์แล้ว ให้บันทึกผลลัพธ์ลงในตาราง BigQuery

ในชุดข้อมูล tfe_codelab ที่คุณเพิ่งสร้าง ให้ตั้งชื่อตารางเป็น ulb_fraud_detection_train แล้วบันทึกข้อมูล

โดยขั้นแรก คลอส WHERE จะแยกข้อมูลด้วยการคำนวณแฮชใน 2 คอลัมน์ จากนั้นจะเลือกแถวที่ส่วนที่เหลือของแฮชเมื่อหารด้วย 10 ต่ำกว่า 80 ซึ่งทำให้เราได้ 80%

ตอนนี้เรามาทำกระบวนการเดียวกันนี้ซ้ำสำหรับชุดข้อมูลการตรวจสอบและความถูกต้องด้วยการค้นหาที่คล้ายกันซึ่งเลือกข้อมูล 10% ในแต่ละชุด

การตรวจสอบความถูกต้อง

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

บันทึกผลลัพธ์ของการค้นหานี้ลงในตารางชื่อ ulb_fraud_detection_val

ทดสอบ

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

บันทึกผลลัพธ์ของการค้นหานี้ลงในตารางชื่อ ulb_fraud_detection_test

3. ตั้งค่าสภาพแวดล้อม Notebook

ตอนนี้เราได้พูดถึงข้อมูลเบื้องต้นไปแล้ว มาตั้งค่าสภาพแวดล้อมการพัฒนาโมเดลกัน

ขั้นตอนที่ 1: เปิดใช้ API

เครื่องมือเชื่อมต่อ BigQuery ใช้ BigQuery Storage API ค้นหา BigQuery Storage API ในคอนโซล แล้วเปิดใช้ API หากปิดใช้อยู่

ขั้นตอนที่ 2: สร้างอินสแตนซ์ Notebooks ของ AI Platform

ไปที่ส่วน AI Platform Notebooks ใน Cloud Console แล้วคลิกอินสแตนซ์ใหม่ จากนั้นเลือกประเภทอินสแตนซ์ TensorFlow Enterprise 1.x ล่าสุดที่ไม่มี GPU ดังนี้

ใช้ตัวเลือกเริ่มต้น แล้วคลิกสร้าง เมื่อสร้างอินสแตนซ์แล้ว ให้เลือกเปิด JupyterLab

จากนั้นสร้างสมุดบันทึก Python 3 จาก JupyterLab โดยทำดังนี้

4. นำเข้าบันทึกจาก BigQuery

ขั้นตอนที่ 1: นำเข้าแพ็กเกจ Python

ในเซลล์แรกของ Notebook ให้เพิ่มการนำเข้าต่อไปนี้และเรียกใช้เซลล์ คุณเรียกใช้ได้โดยกดปุ่มลูกศรขวาในเมนูด้านบนหรือกด 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()

ขั้นตอนที่ 2: กำหนดค่าคงที่

จากนั้นเราจะกำหนดค่าคงที่บางอย่างเพื่อใช้ในโปรเจ็กต์ เปลี่ยน GCP_PROJECT_ID เป็นรหัสโปรเจ็กต์จริงที่คุณใช้ เรียกใช้เซลล์ใหม่ขณะสร้าง

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]

ขั้นตอนที่ 3: กำหนดฟังก์ชันตัวช่วย

ตอนนี้มากำหนดฟังก์ชัน 2-3 ฟังก์ชันกัน read_session() จะอ่านข้อมูลจากตาราง BigQuery ส่วน extract_labels() เป็นฟังก์ชันช่วยในการแยกคอลัมน์ป้ายกำกับออกจากส่วนที่เหลือ เพื่อให้ชุดข้อมูลอยู่ในรูปแบบที่ keras.model_fit() คาดหวังในภายหลัง

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)

ขั้นตอนที่ 4: ส่งผ่านข้อมูล

สุดท้ายนี้ มาสร้างชุดข้อมูลแต่ละชุด แล้วพิมพ์ชุดแรกจากชุดข้อมูลการฝึกกัน โปรดทราบว่าเราได้กำหนด BATCH_SIZE เป็น 32 พารามิเตอร์นี้เป็นพารามิเตอร์ที่สำคัญซึ่งจะส่งผลต่อความเร็วและความแม่นยำของการฝึก

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. สร้างโมเดล

ขั้นตอนที่ 1: ประมวลผลข้อมูลล่วงหน้า

มาสร้างคอลัมน์ฟีเจอร์สำหรับแต่ละฟีเจอร์ในชุดข้อมูลกัน ในชุดข้อมูลนี้ คอลัมน์ทั้งหมดเป็นประเภท numeric_column แต่ก็มีคอลัมน์ประเภทอื่นๆ อีกหลายประเภท (เช่น categorical_column)

ดังที่เราได้กล่าวไปก่อนหน้านี้ เราจะปรับข้อมูลให้มีค่าเฉลี่ยเป็น 0 เพื่อให้เครือข่ายบรรจบกันได้เร็วขึ้น เราได้คำนวณค่าเฉลี่ยของแต่ละฟีเจอร์ไว้ล่วงหน้าเพื่อใช้ในการคำนวณนี้

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

ขั้นตอนที่ 2: สร้างโมเดล

ตอนนี้เราพร้อมที่จะสร้างโมเดลแล้ว เราจะป้อนคอลัมน์ที่เราเพิ่งสร้างลงในเครือข่าย จากนั้นเราจะคอมไพล์โมเดล เราจะรวมเมตริก AUC ของความแม่นยำ/ความอ่อนไหว ซึ่งมีประโยชน์สำหรับชุดข้อมูลที่ไม่สมดุล

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')])

ขั้นตอนที่ 3: ฝึกโมเดล

เทคนิคในการจัดการข้อมูลที่ไม่สมดุลมีอยู่หลายอย่าง ซึ่งรวมถึงการโอเวอร์แซมปลิง (สร้างข้อมูลใหม่ในคลาสส่วนน้อย) และการอันเดอร์แซมปลิง (ลดข้อมูลในคลาสส่วนใหญ่)

ใน Codelab นี้ เราจะใช้เทคนิคที่ให้น้ำหนักความสูญเสียมากเกินไปเมื่อจัดประเภทกลุ่มเสียงข้างน้อยผิด เราจะระบุพารามิเตอร์ class_weight เมื่อฝึกและให้น้ำหนัก "1" (การประพฤติมิชอบ) สูงขึ้น เนื่องจากพบได้น้อยกว่ามาก

เราจะใช้ 3 ยุค (การส่งผ่านข้อมูล) ในแล็บนี้เพื่อให้การฝึกเร็วขึ้น ในสถานการณ์จริง เราต้องการเรียกใช้โมเดลนานพอจนถึงจุดที่ความแม่นยำของชุดข้อมูลการตรวจสอบไม่เพิ่มขึ้นอีก

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)

ขั้นตอนที่ 4: ประเมินโมเดล

ฟังก์ชัน evaluate() สามารถใช้กับข้อมูลการทดสอบที่โมเดลไม่เคยเห็นเพื่อให้การประเมินที่เป็นกลาง โชคดีที่เราได้เตรียมข้อมูลทดสอบไว้สำหรับกรณีนี้โดยเฉพาะ

model.evaluate(test_data)

ขั้นตอนที่ 5: การสำรวจ

ใน Lab นี้ เราได้สาธิตวิธีนำเข้าชุดข้อมูลขนาดใหญ่จาก BigQuery ไปยังโมเดล TensorFlow Keras โดยตรง นอกจากนี้ เรายังได้อธิบายขั้นตอนทั้งหมดในการสร้างโมเดลด้วย สุดท้ายนี้ เราได้เรียนรู้เล็กน้อยเกี่ยวกับวิธีจัดการปัญหาการแยกประเภทที่ไม่สมดุล

คุณสามารถลองใช้สถาปัตยกรรมและแนวทางต่างๆ กับชุดข้อมูลที่ไม่สมดุลต่อไปได้ เพื่อดูว่าคุณจะปรับปรุงความแม่นยำได้หรือไม่

6. ล้างข้อมูล

หากต้องการใช้ Notebook นี้ต่อไป ขอแนะนำให้ปิดเมื่อไม่ได้ใช้งาน จาก UI ของ Notebook ใน Cloud Console ให้เลือก Notebook แล้วเลือกหยุด

หากต้องการลบทรัพยากรทั้งหมดที่คุณสร้างขึ้นใน Lab นี้ เพียงลบอินสแตนซ์ Notebook แทนการหยุด

ใช้เมนูการนำทางใน Cloud Console เพื่อไปที่ Storage แล้วลบทั้ง 2 Bucket ที่คุณสร้างขึ้นเพื่อจัดเก็บชิ้นงานโมเดล