หน้านี้ได้รับการแปลโดย Cloud Translation API

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

1. ภาพรวม

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

สิ่งที่ได้เรียนรู้

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

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

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

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

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

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

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

คลิกแต่ละแท็บเพื่อดูข้อมูลเพิ่มเติมเกี่ยวกับชุดข้อมูลต่อไปนี้

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

ขั้นตอนที่ 2: สืบค้นตาราง

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

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

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

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

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

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

BigQuery มีฟังก์ชันทางสถิติหลายอย่าง ลองมาดูว่าข้อมูลสัมพันธ์กับตัวแปรเป้าหมายคลาสอย่างไร

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 และ .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. ตั้งค่าสภาพแวดล้อมสมุดบันทึก

เราได้นำเสนอข้อมูลอย่างคร่าวๆ ไปแล้ว ต่อไปเรามาตั้งค่าสภาพแวดล้อมการพัฒนาโมเดลกัน

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

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

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

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

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

จากนั้นสร้างสมุดบันทึก Python 3 จาก JupyterLab โดยใช้คำสั่งต่อไปนี้

4. นำเข้าระเบียนจาก BigQuery

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

ในเซลล์แรกของสมุดบันทึก ให้เพิ่มการนำเข้าต่อไปนี้และเรียกใช้เซลล์ โดยกดปุ่มลูกศรขวาในเมนูด้านบนหรือกด 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 รายการ 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: ประมวลผลข้อมูลล่วงหน้า

มาสร้างคอลัมน์ฟีเจอร์สำหรับแต่ละฟีเจอร์ในชุดข้อมูลกันเถอะ ในชุดข้อมูลนี้ คอลัมน์ทั้งหมดเป็นประเภทคอลัมน์ตัวเลข แต่ยังมีคอลัมน์ประเภทอื่นอยู่อีกจำนวนหนึ่ง (เช่น 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 ของ Precision/Recall ซึ่งมีประโยชน์สำหรับชุดข้อมูลที่ไม่สมดุล

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" (การฉ้อโกง) สูงกว่า เนื่องจากพบได้น้อยกว่ามาก

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

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: ประเมินโมเดล

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

model.evaluate(test_data)

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

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

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

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

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

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

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