โมเดล AI ของเสียงลอจิกและโมโนโทนิก

AI กำลังกลายเป็นสินทรัพย์ที่น่าทึ่งอย่างรวดเร็ว โดยได้รับประสิทธิภาพในระดับเหนือมนุษย์ในโดเมน เช่น การจดจำภาพ Go และแม้แต่โป๊กเกอร์ หลายคนตื่นเต้นกับอนาคตของ AI และมนุษยชาติ ในเวลาเดียวกัน มีความรู้สึกว่า AI ประสบกับข้อบกพร่องที่น่ารำคาญอย่างหนึ่ง: AI ในสถานะปัจจุบันอาจไม่น่าเชื่อถืออย่างคาดไม่ถึง

ตัวอย่างคลาสสิกคือ Jeopardy! IBM Challenge ในระหว่างที่ Watson ซึ่งเป็น IBM AI ทำความสะอาดบอร์ดอย่างง่ายดายเพียงเพื่อพลาด "Final Jeopardy!" คำถามซึ่งอยู่ในหมวดหมู่ของ เมืองในสหรัฐฯ : “สนามบินที่ใหญ่ที่สุดตั้งชื่อตามวีรบุรุษสงครามโลกครั้งที่สอง มันใหญ่เป็นอันดับสองสำหรับการต่อสู้ในสงครามโลกครั้งที่สอง” วัตสันตอบว่า “โตรอนโตคืออะไร????”—เครื่องหมายคำถามพิเศษ (และการเดิมพันต่ำ) บ่งบอกถึงความสงสัย

ดังนั้นแม้ว่า AI จะมีความสามารถในการแสดงเหมือนในเทพนิยายเป็นระยะเวลานาน ไม่ว่าจะเป็นเดือน ปี หลายสิบปี ก็ตาม แต่ก็มีความเป็นไปได้ที่จู้จี้อยู่เสมอว่าจู่ๆ มันก็จะเกิดความผิดพลาดอย่างลึกลับ

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

สิ่งนี้ทำให้ฉันสงสัยว่าโมเดล AI ที่ถูกต้องสามารถแก้ไขปัญหานี้ได้หรือไม่ AI ที่เหมาะสมจะมีความสามารถในการตัดสินใจในช่วงเวลาวิกฤติ แม้จะไม่มีคำตอบทั้งหมดหรือไม่ AI ดังกล่าวจะสามารถเปลี่ยนทิศทางของเทคโนโลยีและทำให้เราได้รับผลประโยชน์ราวกับเทพนิยายของ AI...

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

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

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

หมายเหตุบรรณาธิการ: ผู้อ่านที่ต้องการใช้ขั้นตอนแรกของตนเองในการทำความเข้าใจพื้นฐานของ ML ควรอ่านบทความแนะนำของเราเกี่ยวกับ ML

ทฤษฎีแบบจำลอง AI แบบโมโนโทนิก

แล้ว monotonic model คืออะไร? พูดง่ายๆ ก็คือ โมเดลโมโนโทนิกคือโมเดล ML ที่มีคุณสมบัติบางอย่าง ( ฟีเจอร์แบบโมโนโทนิ ก ) ซึ่งการเพิ่มขึ้นจะทำให้โมเดลเพิ่มเอาต์พุตเสมอ

ในชีวิตจริง ตัวแปรหลายคู่แสดงความสัมพันธ์แบบโมโนโทนิก ตัวอย่างเช่น:

• ราคาน้ำมันสำหรับการเดินทางเพิ่มขึ้นอย่างซ้ำซากจำเจในระยะทางที่ขับเคลื่อนด้วย
• โอกาสที่จะได้รับเงินกู้มีมากขึ้นด้วยเครดิตที่ดีกว่า
• เวลาขับขี่ที่คาดหวังจะเพิ่มขึ้นตามปริมาณการจราจร
• รายได้เพิ่มขึ้นตามอัตราการคลิกบนโฆษณา

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

ที่แห่งหนึ่งที่โมเดล AI แบบโมโนโทนิกส่องแสงได้อย่างแท้จริงคือความแข็งแกร่งของคู่ต่อสู้ โมเดลโมโนโทนิกเป็นโมเดลการเรียนรู้ด้วยเครื่อง "แข็ง" ซึ่งหมายความว่าสามารถต้านทานการโจมตีของฝ่ายตรงข้ามได้ ผู้โจมตีที่สามารถจัดการได้เฉพาะคุณลักษณะที่ไม่ใช่แบบโมโนโทนิกเท่านั้น ไม่สามารถหลบเลี่ยงโมเดล AI แบบโมโนโทนิกได้ เนื่องจากพวกเขาไม่สามารถแก้ไขฉลากของตัวอย่างในส่วนที่เกี่ยวกับโมเดล AI แบบโมโนโทนิกได้

กรณีการใช้งานสำหรับโมเดล AI แบบโมโนโทนิก

จนถึงตอนนี้ การอภิปรายนี้เป็นทฤษฎีทั้งหมด มาพูดถึงกรณีการใช้งานในชีวิตจริงกัน

กรณีใช้ #1: การตรวจจับมัลแวร์

หนึ่งในกรณีการใช้งานที่ยอดเยี่ยมที่สุดสำหรับโมเดล AI แบบโมโนโทนิกคือการใช้ในการตรวจจับมัลแวร์ ใช้งานโดยเป็นส่วนหนึ่งของ Windows Defender รุ่นโมโนโทนิกจะมีอยู่ในอุปกรณ์ Windows ที่ทันสมัยทุกเครื่อง ปกป้องผู้ใช้จากมัลแวร์อย่างเงียบๆ

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

แต่ไม่ใช่ในกรณีของโมเดล AI แบบโมโนโทนิกของ Windows Defender ซึ่งฟีเจอร์แบบโมโนโทนิกเป็นเพียงคุณสมบัติที่บ่งบอกถึงมัลแวร์เท่านั้น ไม่ว่าผู้เขียนมัลแวร์ที่มีเนื้อหา "ไม่เป็นพิษเป็นภัย" จะฉีดมัลแวร์เข้าไปมากแค่ไหน โมเดล AI แบบโมโนโทนิกของ Windows Defender จะยังคงจับตัวอย่างและปกป้องผู้ใช้จากความเสียหาย

ในหลักสูตรของฉัน Machine Learning for Red Team Hackers ฉันสอนเทคนิคหลายอย่างในการหลีกเลี่ยงตัวแยกประเภทมัลแวร์ที่ใช้ ML เทคนิคหนึ่งประกอบด้วยการบรรจุตัวอย่างที่เป็นอันตรายด้วยเนื้อหา/คุณลักษณะที่ "ไม่เป็นพิษเป็นภัย" เพื่อหลบเลี่ยงโมเดล ML ที่ไร้เดียงสา โมเดลโมโนโทนิกสามารถต้านทานการโจมตีนี้ได้ และบังคับให้ผู้มุ่งร้ายทำงานหนักขึ้นมาก หากพวกเขาต้องการจะหลบเลี่ยงลักษณนาม

กรณีใช้ #2: การกรองเนื้อหา

สมมติว่าทีมกำลังสร้างตัวกรองเนื้อหาการท่องเว็บสำหรับห้องสมุดโรงเรียน โมเดล AI แบบโมโนโทนิกเป็นตัวเลือกที่ดีที่จะใช้ที่นี่ เนื่องจากฟอรัมที่มีเนื้อหาที่ไม่เหมาะสมอาจมีเนื้อหาที่ยอมรับได้มากมาย

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

ใช้กรณี #3: AI รถยนต์ที่ขับด้วยตนเอง

ลองนึกภาพการสร้างอัลกอริธึมรถยนต์ที่ขับด้วยตนเอง ดูภาพแล้วเห็นไฟเขียว ยังเห็นคนเดินถนน ควรชั่งน้ำหนักสัญญาณของกันและกันหรือไม่? ไม่ได้อย่างแน่นอน. การปรากฏตัวของคนเดินเท้าก็เพียงพอที่จะตัดสินใจหยุดรถ การมีอยู่ของคนเดินเท้าควรถูกมองว่าเป็นคุณลักษณะแบบโมโนโทนิก และควรใช้โมเดล AI แบบโมโนโทนิกในสถานการณ์นี้

ใช้กรณี #4: เครื่องมือแนะนำ

เอ็นจิ้นการแนะนำเป็นกรณีการใช้งานที่ยอดเยี่ยมสำหรับโมเดล AI แบบโมโนโทนิก โดยทั่วไป อาจมีข้อมูลป้อนเข้ามากมายเกี่ยวกับแต่ละผลิตภัณฑ์: ระดับดาว ราคา จำนวนบทวิจารณ์ ฯลฯ โดยที่ข้อมูลอื่น ๆ ทั้งหมดเท่ากัน เช่น ระดับดาวและราคา เราจึงควรเลือกใช้ผลิตภัณฑ์ที่มีจำนวนบทวิจารณ์มากกว่า เราสามารถบังคับใช้ตรรกะดังกล่าวได้โดยใช้แบบจำลอง AI แบบโมโนโทนิก

กรณีการใช้งาน #5: การกรองสแปมและฟิชชิ่ง

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

การดำเนินการและการสาธิต

เมื่อพูดถึงการใช้งานฟรีของโมเดล AI แบบโมโนโทนิก สามรุ่นที่โดดเด่นที่สุดคือ XGBoost, LightGBM และ TensorFlow Lattice

บทช่วยสอน ML XGBoost แบบโมโนโทนิก

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

บทช่วยสอน XGBoost สาธิตต่อไปนี้เกี่ยวกับวิธีใช้โมเดล ML แบบโมโนโทนิกมี Python repo ที่มาพร้อมกัน

เริ่มต้นด้วยการนำเข้าไลบรารีสองสามตัว:

 import random import numpy as np import matplotlib.pyplot as plt %matplotlib inline from sklearn.metrics import confusion_matrix import seaborn as sns sns.set(font_scale=1.4)

สถานการณ์ที่เราจะสร้างโมเดลคือการกรองเนื้อหาหรือฐานข้อมูลมัลแวร์ เราจะมี benign_features บางอย่าง ซึ่งโมเดล เช่น จำนวนเนื้อหาที่เกี่ยวข้องกับ "วิทยาศาสตร์" "ประวัติศาสตร์" และ "กีฬา" หรือในกรณีของมัลแวร์ "การลงนามโค้ด" และ "ผู้เขียนที่รู้จัก"

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

เราจะจำลองสถานการณ์ผ่านแบบจำลองกำเนิด เราสร้างจุดข้อมูลจำนวนมากโดยสุ่ม ประมาณครึ่งหนึ่งที่ไม่เป็นอันตรายและเป็นอันตรายครึ่งหนึ่ง โดยใช้ฟังก์ชัน:

 def flip(): """Simulates a coin flip.""" return 1 if random.random() < 0.5 else 0

จุดข้อมูลแต่ละจุดจะสุ่มสร้างคุณลักษณะ จุดข้อมูลที่ "ไม่เป็นอันตราย" จะมีอคติสูงกว่าสำหรับคุณลักษณะที่ไม่เป็นอันตราย ในขณะที่จุดข้อมูลที่ "เป็นอันตราย" จะมีอคติสูงกว่าสำหรับคุณลักษณะที่เป็นอันตราย

เราจะใช้การกระจายแบบสามเหลี่ยม เช่น:

 bins = [0.1 * i for i in range(12)] plt.hist([random.triangular(0, 1, 1) for i in range(50000)], bins) 

เราจะใช้ฟังก์ชันนี้เพื่อจับตรรกะข้างต้น:

 def generate(): """Samples from the triangular distribution.""" return random.triangular(0, 1, 1)

จากนั้น เราจะดำเนินการสร้างชุดข้อมูลของเรา:

 m = 100000 benign_features = 5 malicious_features = 5 n = benign_features + malicious_features benign = 0 malicious = 1 X = np.zeros((m, n)) y = np.zeros((m)) for i in range(m): vec = np.zeros((n)) y[i] = flip() if y[i] == benign: for j in range(benign_features): vec[j] = generate() for j in range(malicious_features): vec[j + benign_features] = 1 - generate() else: for j in range(benign_features): vec[j] = 1 - generate() for j in range(malicious_features): vec[j + benign_features] = generate() X[i, :] = vec

X มีเวกเตอร์ของคุณลักษณะที่สร้างแบบสุ่ม ในขณะที่ y มีป้ายกำกับ ปัญหาการจัดหมวดหมู่นี้ไม่สำคัญ

คุณจะเห็นได้ว่าตัวอย่างที่ไม่เป็นอันตรายโดยทั่วไปมีน้ำหนักมากกว่าในคุณสมบัติสองสามอย่างแรก ในขณะที่ตัวอย่างที่เป็นอันตรายมักจะมีน้ำหนักมากกว่าในคุณสมบัติสองสามอย่างล่าสุด

เมื่อข้อมูลพร้อมแล้ว เรามาทำการแบ่งการทดสอบการฝึกแบบง่ายๆ กัน:

 from sklearn.model_selection import train_test_split X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

เราจะใช้ฟังก์ชันเพื่อเตรียมข้อมูลสำหรับใช้กับบทช่วยสอน XGBoost ของเรา:

 import xgboost as xgb def prepare_for_XGBoost(X, y): """Converts a numpy X and y dataset into a DMatrix for XGBoost.""" return xgb.DMatrix(X, label=y) dtrain = prepare_for_XGBoost(X_train, y_train) dtest = prepare_for_XGBoost(X_test, y_test) dall = prepare_for_XGBoost(X, y)

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

 params = {"n_jobs": -1, "tree_method": "hist"} model_no_constraints = xgb.train(params=params, dtrain=dtrain) CM = predict_with_XGBoost_and_return_confusion_matrix( model_no_constraints, dtrain, y_train ) plt.figure(figsize=(12, 10)) sns.heatmap(CM / np.sum(CM), annot=True, fmt=".2%", cmap="Blues") plt.ylabel("True Label") plt.xlabel("Predicted Label") plt.title("Unconstrained model's training confusion matrix") plt.show() print() CM = predict_with_XGBoost_and_return_confusion_matrix( model_no_constraints, dtest, y_test ) plt.figure(figsize=(12, 10)) sns.heatmap(CM / np.sum(CM), annot=True, fmt=".2%", cmap="Blues") plt.ylabel("True Label") plt.xlabel("Predicted Label") plt.title("Unconstrained model's testing confusion matrix") plt.show() model_no_constraints = xgb.train(params=params, dtrain=dall) 

เมื่อดูจากผลลัพธ์ เราจะเห็นว่าไม่มีการโอเวอร์ฟิตที่มีนัยสำคัญ เราจะเปรียบเทียบผลลัพธ์เหล่านี้กับผลลัพธ์ของแบบจำลองโมโนโทนิก

ด้วยเหตุนี้ เรามาฝึกและทดสอบโมเดล XGBoost แบบโมโนโทนิกกัน ไวยากรณ์ที่เราส่งผ่านในข้อจำกัดเสียงเดียวคือลำดับ ( f ₀ , f ₁ , …, f _N ) โดยที่แต่ละ f _i เป็นหนึ่งใน -1, 0 หรือ 1 ขึ้นอยู่กับว่าเราต้องการให้ฟีเจอร์ i เป็นแบบโมโนโทนหรือไม่ ลดลง ไม่มีข้อจำกัด หรือเพิ่มขึ้นอย่างซ้ำซากจำเจตามลำดับ ในกรณีที่อยู่ในมือ เราระบุคุณลักษณะที่เป็นอันตรายให้เพิ่มขึ้นแบบโมโนโทนิก

 params_constrained = params.copy() monotone_constraints = ( "(" + ",".join([str(0) for m in range(benign_features)]) + "," + ",".join([str(1) for m in range(malicious_features)]) + ")" ) print("Monotone constraints enforced are:") print(monotone_constraints) params_constrained["monotone_constraints"] = monotone_constraints model_monotonic = xgb.train(params=params_constrained, dtrain=dtrain) CM = predict_with_XGBoost_and_return_confusion_matrix(model_monotonic, dtrain, y_train) plt.figure(figsize=(12, 10)) sns.heatmap(CM / np.sum(CM), annot=True, fmt=".2%", cmap="Blues") plt.ylabel("True Label") plt.xlabel("Predicted Label") plt.title("Monotonic model's training confusion matrix") plt.show() print() CM = predict_with_XGBoost_and_return_confusion_matrix(model_monotonic, dtest, y_test) plt.figure(figsize=(12, 10)) sns.heatmap(CM / np.sum(CM), annot=True, fmt=".2%", cmap="Blues") plt.ylabel("True Label") plt.xlabel("Predicted Label") plt.title("Monotonic model's testing confusion matrix") plt.show() model_monotonic = xgb.train(params=params_constrained, dtrain=dall) 

เป็นที่ชัดเจนว่าประสิทธิภาพของโมเดลโมโนโทนิกนั้นเหมือนกับของโมเดลที่ไม่มีข้อจำกัด

ตอนนี้ เรากำลังจะสร้างชุดข้อมูลที่เป็นปฏิปักษ์ เราจะนำตัวอย่างที่เป็นอันตรายทั้งหมดและ "บรรจุ" คุณลักษณะที่ไม่เป็นพิษเป็นภัยโดยการตั้งค่าทั้งหมดเป็น 1 จากนั้นเราจะดูว่าทั้งสองรุ่นทำงานเคียงข้างกันอย่างไร

 X_adversarial = X[y == malicious] y_adversarial = len(X_adversarial) * [malicious] for i in range(len(X_adversarial)): vec = X_adversarial[i, :] for j in range(benign_features): vec[j] = 1 X_adversarial[i, :] = vec

มาแปลงเป็นแบบฟอร์มที่จะนำเข้าโดย XGBoost:

 dadv = prepare_for_XGBoost(X_adversarial, y_adversarial)

สำหรับขั้นตอนสุดท้ายของบทช่วยสอน XGBoost เราจะทดสอบโมเดลแมชชีนเลิร์นนิงสองประเภท:

 CM = predict_with_XGBoost_and_return_confusion_matrix( model_no_constraints, dadv, y_adversarial ) plt.figure(figsize=(12, 10)) sns.heatmap(CM / np.sum(CM), annot=True, fmt=".2%", cmap="Blues") plt.ylabel("True Label") plt.xlabel("Predicted Label") plt.title("Unconstrained model's confusion matrix on adversarial dataset") plt.show()

 CM = predict_with_XGBoost_and_return_confusion_matrix( model_monotonic, dadv, y_adversarial ) plt.figure(figsize=(12, 10)) sns.heatmap(CM / np.sum(CM), annot=True, fmt=".2%", cmap="Blues") plt.ylabel("True Label") plt.xlabel("Predicted Label") plt.title("Monotonic model's confusion matrix on adversarial dataset") plt.show() 

อย่างที่คุณเห็น โมเดล AI แบบโมโนโทนิกนั้นแข็งแกร่งกว่าการโจมตีของฝ่ายตรงข้ามถึง 2,500 เท่า

LightGBM

ไวยากรณ์สำหรับการใช้คุณสมบัติโมโนโทนิกใน LightGBM นั้นคล้ายคลึงกัน

TensorFlow Lattice

TensorFlow Lattice เป็นเฟรมเวิร์กอื่นสำหรับจัดการกับข้อจำกัดเกี่ยวกับความซ้ำซากจำเจ และเป็นชุดของตัวประมาณค่า TensorFlow ที่สร้างไว้ล่วงหน้า รวมถึงตัวดำเนินการ TensorFlow เพื่อสร้างแบบจำลองแลตทิซของคุณเอง Lattices เป็นตารางค้นหาแบบ interpolated แบบหลายมิติ ซึ่งหมายความว่าเป็นจุดกระจายอย่างสม่ำเสมอในช่องว่าง (เช่น ตาราง) พร้อมกับค่าฟังก์ชันที่จุดเหล่านี้ ตามบล็อก Google AI:

“…ค่าตารางค้นหาได้รับการฝึกฝนเพื่อลดการสูญเสียในตัวอย่างการฝึก แต่นอกจากนี้ ค่าที่อยู่ติดกันในตารางค้นหายังถูกจำกัดให้เพิ่มขึ้นตามทิศทางที่กำหนดของพื้นที่อินพุต ซึ่งทำให้ผลลัพธ์ของแบบจำลองเพิ่มขึ้น ทิศทางเหล่านั้น ที่สำคัญ เนื่องจากพวกมันสอดแทรกระหว่างค่าตารางค้นหา โมเดลแลตทิซจึงราบรื่นและการคาดการณ์มีขอบเขต ซึ่งช่วยหลีกเลี่ยงการคาดคะเนขนาดใหญ่หรือเล็กที่จอมปลอมในเวลาทดสอบ”

บทแนะนำสำหรับวิธีใช้ TensorFlow Lattice สามารถพบได้ที่นี่

โมเดล AI แบบโมโนโทนิกและอนาคต

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