การใช้งานโมเดลการเรียนรู้ของเครื่องต่างๆ ใน ​​Python: คู่มือที่ครอบคลุม

เนื้อหาของบทความ:

ฉัน บทนำ

• ภาพรวมโดยย่อของการเรียนรู้ของเครื่องและการใช้งาน
• คำอธิบายของโมเดลการเรียนรู้ของเครื่องประเภทต่างๆ (ภายใต้การดูแล ไม่ได้รับการดูแล การเสริมกำลัง ฯลฯ)

ครั้งที่สอง โมเดลการเรียนรู้แบบมีผู้สอน

ก. การถดถอยเชิงเส้น

• คำอธิบายการทำงานของการถดถอยเชิงเส้น
• การใช้งานใน Python โดยใช้ไลบรารี scikit-learn

บี การถดถอยโลจิสติก

• คำอธิบายวิธีการทำงานของการถดถอยโลจิสติก
• การใช้งานใน Python โดยใช้ไลบรารี scikit-learn

ซี ต้นไม้การตัดสินใจ

• คำอธิบายวิธีการทำงานของแผนผังการตัดสินใจ
• การใช้งานใน Python โดยใช้ไลบรารี scikit-learn

ดี. ป่าสุ่ม

• คำอธิบายการทำงานของป่าสุ่ม
• การใช้งานใน Python โดยใช้ไลบรารี scikit-learn

สาม. รูปแบบการเรียนรู้แบบไม่มีผู้ดูแล

ก. การจัดกลุ่ม K-Means

• คำอธิบายวิธีการทำงานของการจัดกลุ่มแบบเคมีน
• การใช้งานใน Python โดยใช้ไลบรารี scikit-learn

บี การวิเคราะห์องค์ประกอบหลัก (PCA)

• คำอธิบายวิธีการทำงานของ PCA
• การใช้งานใน Python โดยใช้ไลบรารี scikit-learn

ซี การจัดกลุ่มแบบลำดับชั้น

• คำอธิบายวิธีการทำงานของการจัดกลุ่มแบบลำดับชั้น
• การใช้งานใน Python โดยใช้ไลบรารี scikit-learn

IV. รูปแบบการเรียนรู้แบบเสริมกำลัง

ก. ถาม-การเรียนรู้

• คำอธิบายการทำงานของ Q-learning
• การใช้งานใน Python โดยใช้ไลบรารี Keras

บี ซาร์ซา

• คำอธิบายวิธีการทำงานของ SARSA
• การใช้งานใน Python โดยใช้ไลบรารี Keras

โวลต์ บทสรุป

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

ฉัน บทนำ

• ภาพรวมโดยย่อของแมชชีนเลิร์นนิงและแอปพลิเคชัน

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

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

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

• คำอธิบายโมเดลแมชชีนเลิร์นนิงประเภทต่างๆ (ภายใต้การดูแล ไม่ได้รับการดูแล การเสริมกำลัง ฯลฯ)

โมเดลการเรียนรู้ของเครื่องมีหลายประเภท แต่ละประเภทมีลักษณะเฉพาะและการใช้งานเฉพาะของตัวเอง ซึ่งรวมถึง:

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

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

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

4. การเรียนรู้แบบกึ่งมีผู้สอน: โมเดลการเรียนรู้แบบกึ่งมีผู้สอนเป็นการผสมผสานระหว่างการเรียนรู้แบบมีผู้สอนและแบบไม่มีผู้สอน พวกเขาได้รับการฝึกอบรมโดยใช้ข้อมูลที่มีทั้งแบบมีป้ายกำกับและไม่มีป้ายกำกับผสมกัน มีการใช้ในการใช้งานหลายอย่าง เช่น การประมวลผลภาษาธรรมชาติ คอมพิวเตอร์วิทัศน์ และการดึงข้อมูล

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

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

ครั้งที่สอง รูปแบบการเรียนรู้ภายใต้การดูแล

ก. การถดถอยเชิงเส้น

• คำอธิบายวิธีการทำงานของการถดถอยเชิงเส้น

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

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

y = b0 + b1x1 + b2x2 + … + bnxn

โดยที่: y คือตัวแปรเป้าหมาย b0, b1, b2, …, bn คือสัมประสิทธิ์ของตัวแปรอินพุต x1, x2, …, xn คือตัวแปรอินพุต

เป้าหมายของการถดถอยเชิงเส้นคือการค้นหาค่าที่ดีที่สุดสำหรับสัมประสิทธิ์ (b0, b1, b2, …, bn) ซึ่งจะลดความแตกต่างระหว่างค่าที่ทำนายของตัวแปรเป้าหมายและค่าจริงให้เหลือน้อยที่สุด โดยทั่วไปจะทำโดยใช้วิธีที่เรียกว่ากำลังสองน้อยที่สุด ซึ่งจะค้นหาค่าของสัมประสิทธิ์ที่จะลดผลรวมของกำลังสองของความแตกต่างระหว่างค่าที่คาดการณ์ไว้และค่าจริงให้เหลือน้อยที่สุด

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

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

• การใช้งานใน Python โดยใช้ไลบรารี scikit-learn

การถดถอยเชิงเส้น สามารถนำไปใช้ได้อย่างง่ายดายใน Python โดยใช้ไลบรารี scikit-learn ไลบรารีมีคลาส LinearRegression ในตัว ซึ่งสามารถใช้เพื่อสร้างและฝึกโมเดลการถดถอยเชิงเส้น นี่คือตัวอย่างวิธีใช้คลาส LinearRegression เพื่อฝึกโมเดลการถดถอยเชิงเส้น:

from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split

# Import data
X = [[1, 2], [2, 3], [3, 4], [4, 5]] # Input variables
y = [1, 2, 3, 4] # Target variable

# Split data into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2,
                                   random_state=0)

# Create and train the linear regression model
lin_reg = LinearRegression()
lin_reg.fit(X_train, y_train)

# Predict target variable for test data
y_pred = lin_reg.predict(X_test)

# Print coefficients and score of the model
print("Coefficients: ", lin_reg.coef_)
print("Intercept: ", lin_reg.intercept_)
print("Score: ", lin_reg.score(X_test, y_test))

ในตัวอย่างนี้ ก่อนอื่นเราจะนำเข้าคลาส LinearRegression จากโมดูล sklearn.linear_model และฟังก์ชัน train_test_split จากโมดูล sklearn.model_selection จากนั้น เราจะนำเข้าข้อมูล ในกรณีนี้ นี่เป็นตัวอย่างง่ายๆ ที่มีตัวแปรอินพุตเพียงสองตัว และตัวแปรเป้าหมายหนึ่งตัว ต่อไป เราใช้ฟังก์ชัน train_test_split เพื่อแบ่งข้อมูลออกเป็นชุดการฝึกและการทดสอบ เราใช้ข้อมูล 80% สำหรับการฝึกอบรมและ 20% สำหรับการทดสอบ

เราสร้างอินสแตนซ์ของคลาส LinearRegression และเรียกใช้เมธอด fit() เพื่อฝึกโมเดลกับข้อมูลการฝึก fit() วิธีการรับตัวแปรอินพุตและตัวแปรเป้าหมายเป็นอาร์กิวเมนต์

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

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

ในตัวอย่างนี้ โมเดลการถดถอยเชิงเส้นนี้สามารถตีความได้ว่าเป็นแบบจำลองที่ตัวแปรเป้าหมาย y เท่ากับ 1.5 เท่าของค่าของตัวแปรอินพุตตัวแรก x1 บวก 1 เท่าของค่าของตัวแปรอินพุตตัวที่สอง x2

เป็นที่น่าสังเกตว่าคุณควรติดตั้งไลบรารี scikit-learn ก่อนที่จะลองใช้มันในโค้ดของคุณ คุณสามารถทำได้โดยการรัน pip install scikit-learn ใน command prompt หรือ terminal

บี การถดถอยโลจิสติก

• คำอธิบายวิธีการทำงานของการถดถอยโลจิสติก

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

สมการการถดถอยโลจิสติกสามารถแสดงได้ด้วยสมการต่อไปนี้:

p(y = 1) = 1 / (1 + e^-(b0 + b1x1 + b2x2 + … + bnxn))

โดยที่: p(y = 1) คือความน่าจะเป็นของผลลัพธ์ที่เป็น 1 b0, b1, b2, …, bn คือสัมประสิทธิ์ของตัวแปรอินพุต x1, x2, …, xn คือตัวแปรอินพุต

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

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

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

• การใช้งานใน Python โดยใช้ไลบรารี scikit-learn

การถดถอยโลจิสติก สามารถนำไปใช้ได้อย่างง่ายดายใน Python โดยใช้ไลบรารี scikit-learn ไลบรารีมีคลาส LogisticRegression ในตัว ซึ่งสามารถใช้เพื่อสร้างและฝึกโมเดลการถดถอยโลจิสติก นี่คือตัวอย่างวิธีใช้คลาส LogisticRegression เพื่อฝึกโมเดลการถดถอยโลจิสติก:

from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split

# Import data
X = [[1, 2], [2, 3], [3, 4], [4, 5]] # Input variables
y = [0, 0, 1, 1] # Target variable (0 or 1)

# Split data into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, 
                                   random_state=0)

# Create and train the logistic regression model
log_reg = LogisticRegression()
log_reg.fit(X_train, y_train)

# Predict target variable for test data
y_pred = log_reg.predict(X_test)

# Print coefficients and score of the model
print("Coefficients: ", log_reg.coef_)
print("Intercept: ", log_reg.intercept_)
print("Score: ", log_reg.score(X_test, y_test))

กระบวนการนี้คล้ายกับตัวอย่างการถดถอยเชิงเส้น โดยที่เรานำเข้าคลาส LogisticRegression จากโมดูล sklearn.linear_model ก่อน และฟังก์ชัน train_test_split จากโมดูล sklearn.model_selection จากนั้นเรานำเข้าข้อมูลและใช้ฟังก์ชัน train_test_split เพื่อแบ่งข้อมูลออกเป็นชุดการฝึกอบรมและการทดสอบ

เราสร้างอินสแตนซ์ของคลาส LogisticRegression และเรียกใช้เมธอด fit() เพื่อฝึกโมเดลกับข้อมูลการฝึก fit() วิธีการรับตัวแปรอินพุตและตัวแปรเป้าหมายเป็นอาร์กิวเมนต์

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

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

เป็นที่น่าสังเกตว่าคุณควรติดตั้งไลบรารี scikit-learn ก่อนที่จะลองใช้มันในโค้ดของคุณ คุณสามารถทำได้โดยการรัน pip install scikit-learn ใน command prompt หรือ terminal นอกจากนี้ ในตัวอย่างนี้ การถดถอยโลจิสติกเป็นแบบจำลองที่ตัวแปรเป้าหมาย y ถูกกำหนดตามค่าของตัวแปรอินพุตตัวแรกและตัวที่สอง x1 และ x2 ตามลำดับ

ซี ต้นไม้การตัดสินใจ

• คำอธิบายว่าแผนผังการตัดสินใจทำงานอย่างไร

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

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

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

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

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

ดังนั้น เพื่อเอาชนะข้อจำกัดเหล่านี้ แผนผังการตัดสินใจจึงสามารถนำมาใช้ร่วมกับโมเดลอื่นๆ เช่น Random Forest

• การใช้งานใน Python โดยใช้ไลบรารี scikit-learn

แผนผังการตัดสินใจ สามารถนำไปใช้งานได้อย่างง่ายดายใน Python โดยใช้ไลบรารี scikit-learn ไลบรารีมีคลาส DecisionTreeClassifier ในตัวสำหรับงานการจัดหมวดหมู่ และคลาส DecisionTreeRegressor สำหรับงานการถดถอย นี่คือตัวอย่างวิธีใช้คลาส DecisionTreeClassifier เพื่อฝึกโมเดลแผนผังการตัดสินใจสำหรับการจัดหมวดหมู่:

from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import train_test_split

# Import data
X = [[1, 2], [2, 3], [3, 4], [4, 5]] # Input variables
y = [0, 0, 1, 1] # Target variable (0 or 1)

# Split data into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2,
                                   random_state=0)

# Create and train the decision tree model
tree_clf = DecisionTreeClassifier()
tree_clf.fit(X_train, y_train)

# Predict target variable for test data
y_pred = tree_clf.predict(X_test)

# Print accuracy of the model
print("Accuracy: ", tree_clf.score(X_test, y_test))

กระบวนการนี้คล้ายกับตัวอย่างการถดถอยเชิงเส้นและลอจิสติก โดยที่เรานำเข้าคลาส DecisionTreeClassifier จากโมดูล sklearn.tree ก่อน และฟังก์ชัน train_test_split จากโมดูล sklearn.model_selection จากนั้นเรานำเข้าข้อมูลและใช้ฟังก์ชัน train_test_split เพื่อแบ่งข้อมูลออกเป็นชุดการฝึกอบรมและการทดสอบ

เราสร้างอินสแตนซ์ของคลาส DecisionTreeClassifier และเรียกใช้เมธอด fit() เพื่อฝึกโมเดลกับข้อมูลการฝึก fit() วิธีการรับตัวแปรอินพุตและตัวแปรเป้าหมายเป็นอาร์กิวเมนต์

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

นอกจากนี้เรายังสามารถตรวจสอบความถูกต้องของแบบจำลองได้ด้วยการเปรียบเทียบค่าเป้าหมายที่คาดการณ์ไว้กับค่าจริง

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

ดี. ป่าสุ่ม

• คำอธิบายวิธีการทำงานของป่าสุ่ม

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

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

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

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

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

โดยรวมแล้ว ป่าสุ่มมีการใช้กันอย่างแพร่หลายในการใช้งานหลายอย่าง เช่น การประมวลผลภาษาธรรมชาติ คอมพิวเตอร์

• การใช้งานใน Python โดยใช้ไลบรารี scikit-learn

ฟอเรสต์แบบสุ่มสามารถนำไปใช้ได้อย่างง่ายดายใน Python โดยใช้ไลบรารี scikit-learn ไลบรารีมีคลาส RandomForestClassifier ในตัวสำหรับงานการจัดหมวดหมู่ และคลาส RandomForestRegressor สำหรับงานการถดถอย นี่คือตัวอย่างวิธีใช้คลาส RandomForestClassifier เพื่อฝึกโมเดลฟอเรสต์แบบสุ่มสำหรับการจัดหมวดหมู่:

from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split

# Import data
X = [[1, 2], [2, 3], [3, 4], [4, 5]] # Input variables
y = [0, 0, 1, 1] # Target variable (0 or 1)

# Split data into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2,
                                   random_state=0)

# Create and train the random forest model
rf_clf = RandomForestClassifier()
rf_clf.fit(X_train, y_train)

# Predict target variable for test data
y_pred = rf_clf.predict(X_test)

# Print accuracy of the model
print("Accuracy: ", rf_clf.score(X_test, y_test))

กระบวนการนี้คล้ายกับตัวอย่างแผนผังการตัดสินใจที่เรานำเข้าคลาส RandomForestClassifier จากโมดูล sklearn.ensemble ก่อน และฟังก์ชัน train_test_split จากโมดูล sklearn.model_selection จากนั้นเรานำเข้าข้อมูลและใช้ฟังก์ชัน train_test_split เพื่อแบ่งข้อมูลออกเป็นชุดการฝึกอบรมและการทดสอบ

เราสร้างอินสแตนซ์ของคลาส RandomForestClassifier และเรียกใช้เมธอด fit() เพื่อฝึกโมเดลกับข้อมูลการฝึก fit() วิธีการรับตัวแปรอินพุตและตัวแปรเป้าหมายเป็นอาร์กิวเมนต์

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

นอกจากนี้เรายังสามารถตรวจสอบความถูกต้องของแบบจำลองได้ด้วยการเปรียบเทียบค่าเป้าหมายที่คาดการณ์ไว้กับค่าจริง

เป็นที่น่าสังเกตว่าคุณควรติดตั้งไลบรารี scikit-learn ก่อนที่จะลองใช้มันในโค้ดของคุณ คุณสามารถทำได้โดยการรัน pip install scikit-learn ใน command prompt หรือ terminal

นอกจากนี้ สามารถระบุจำนวนแผนผังการตัดสินใจในฟอเรสต์ได้โดยใช้พารามิเตอร์ n_estimators โดยค่าเริ่มต้นจะถูกตั้งค่าไว้

III. โมเดลการเรียนรู้แบบไม่มีผู้ดูแล

ก. การจัดกลุ่ม K-Means

• คำอธิบายวิธีการทำงานของการจัดกลุ่มเคมีน

การจัดกลุ่มแบบ K-means เป็นอัลกอริทึมการเรียนรู้แบบไม่มีผู้ดูแลชนิดหนึ่งที่ใช้ในการจัดกลุ่มจุดข้อมูลที่คล้ายกันเข้าด้วยกันเป็นกลุ่ม เป้าหมายของการจัดกลุ่มแบบเคมีนคือการแบ่งชุดข้อมูลออกเป็น k คลัสเตอร์ โดยที่แต่ละคลัสเตอร์จะแสดงด้วยเซนทรอยด์ (หรือเรียกอีกอย่างว่าค่าเฉลี่ยของจุดข้อมูลในคลัสเตอร์)

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

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

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

อย่างไรก็ตาม การจัดกลุ่มเคมีนก็มีข้อจำกัดบางประการเช่นกัน อัลกอริธึมนั้นไวต่อตัวเลือกเริ่มต้น

• การใช้งานใน Python โดยใช้ไลบรารี scikit-learn

การจัดกลุ่ม K-meansสามารถนำไปใช้งานได้อย่างง่ายดายใน Python โดยใช้ไลบรารี scikit-learn ไลบรารีมีคลาส KMeans ในตัว ซึ่งสามารถใช้เพื่อสร้างและฝึกโมเดลการจัดกลุ่ม k-means นี่คือตัวอย่างวิธีใช้คลาส KMeans เพื่อจัดกลุ่มชุดข้อมูลออกเป็น 2 คลัสเตอร์:

from sklearn.cluster import KMeans
import numpy as np

# Import data
X = np.array([[1, 2], [2, 3], [3, 4], [4, 5],
              [1, 2], [2, 3], [3, 4], [4, 5]]) # Input variables

# Create and train the k-means model
kmeans = KMeans(n_clusters=2)
kmeans.fit(X)

# Predict the cluster for each data point
y_pred = kmeans.predict(X)

# Print the cluster centers
print("Cluster centers: ", kmeans.cluster_centers_)

กระบวนการนี้คล้ายกับตัวอย่างการถดถอยเชิงเส้นและลอจิสติก โดยเราจะนำเข้าคลาส KMeans จากโมดูล sklearn.cluster ก่อน จากนั้นเรานำเข้าข้อมูล ในตัวอย่างนี้ เราใช้อาร์เรย์จำนวน 8 จุดข้อมูล

เราสร้างอินสแตนซ์ของคลาส KMeans และเรียกใช้เมธอด fit() เพื่อฝึกโมเดลกับข้อมูล fit() วิธีการรับตัวแปรอินพุตเป็นอาร์กิวเมนต์

สิ่งสำคัญที่ควรทราบก็คือ เราจำเป็นต้องระบุจำนวนคลัสเตอร์ k เป็นอาร์กิวเมนต์ของคลาส KMeans ที่นี่เราระบุว่าเราต้องการจัดกลุ่มข้อมูลออกเป็น 2 คลัสเตอร์

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

นอกจากนี้เรายังสามารถตรวจสอบศูนย์กลางคลัสเตอร์ของโมเดล ซึ่งเป็นค่าเฉลี่ยของจุดข้อมูลที่กำหนดให้กับคลัสเตอร์นั้น

เป็นที่น่าสังเกตว่าคุณควรติดตั้งไลบรารี scikit-learn ก่อนที่จะลองใช้มันในโค้ดของคุณ คุณสามารถทำได้โดยการรัน pip install scikit-learn ใน command prompt หรือ terminal นอกจากนี้ ในตัวอย่างนี้ แบบจำลองเคมีนจะจัดกลุ่มจุดข้อมูล 4 จุดแรกไว้ด้วยกัน และจัดกลุ่มจุดข้อมูล 4 จุดสุดท้ายไว้ด้วยกันเนื่องจากมีความคล้ายคลึงกันมาก

B. การวิเคราะห์องค์ประกอบหลัก (PCA)

• คำอธิบายวิธีการทำงานของ PCA

การวิเคราะห์องค์ประกอบหลัก (PCA) เป็นเทคนิคการลดขนาดที่ใช้เพื่อลดความซับซ้อนของชุดข้อมูลมิติสูงโดยการระบุและรักษาคุณลักษณะที่สำคัญที่สุด (หรือที่เรียกว่าองค์ประกอบหลัก) ที่อธิบายความแปรปรวนมากที่สุดใน ข้อมูล. แนวคิดหลักเบื้องหลัง PCA คือการฉายภาพข้อมูลต้นฉบับลงบนพื้นที่มิติล่างใหม่ที่รวบรวมคุณลักษณะที่สำคัญที่สุดของข้อมูล

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

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

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

อย่างไรก็ตาม PCA ก็มีข้อจำกัดบางประการเช่นกัน อัลกอริธึมมีความอ่อนไหวต่อการปรับขนาดข้อมูล ดังนั้นจึงแนะนำให้สร้างมาตรฐานของข้อมูลก่อนที่จะใช้ PCA นอกจากนี้ PCA ยังไม่ทนทานต่อค่าผิดปกติ ดังนั้นจึงแนะนำให้ลบค่าผิดปกติออกก่อนที่จะใช้ PCA

โดยรวมแล้ว PCA ถูกนำมาใช้กันอย่างแพร่หลายในแอปพลิเคชันจำนวนมาก เช่น การบีบอัดรูปภาพ การแยกคุณลักษณะ และการแสดงภาพข้อมูล

• การใช้งานใน Python โดยใช้ไลบรารี scikit-learn

การวิเคราะห์องค์ประกอบหลัก (PCA) สามารถนำไปใช้งานได้อย่างง่ายดายใน Python โดยใช้ไลบรารี scikit-learn ไลบรารีมีคลาส PCA ในตัว ซึ่งสามารถใช้เพื่อสร้างและฝึกอบรมโมเดล PCA นี่คือตัวอย่างวิธีใช้คลาส PCA เพื่อลดมิติของชุดข้อมูล:

from sklearn.decomposition import PCA
import numpy as np

# Import data
X = np.array([[1, 2], [2, 3], [3, 4], [4, 5], [1, 2],
              [2, 3], [3, 4], [4, 5]]) # Input variables

# Create and train the PCA model
pca = PCA(n_components=1)
pca.fit(X)

# Transform the data
X_transformed = pca.transform(X)

# Print the explained variance
print("Explained variance: ", pca.explained_variance_ratio_)

กระบวนการนี้คล้ายกับตัวอย่างการจัดกลุ่มเคมีน โดยที่เรานำเข้าคลาส PCA จากโมดูล sklearn.decomposition ก่อน จากนั้นเรานำเข้าข้อมูล ในตัวอย่างนี้ เราใช้อาร์เรย์จำนวน 8 จุดข้อมูล

เราสร้างอินสแตนซ์ของคลาส PCA และเรียกใช้เมธอด fit() เพื่อฝึกโมเดลกับข้อมูล fit() วิธีการรับตัวแปรอินพุตเป็นอาร์กิวเมนต์

สิ่งสำคัญที่ควรทราบก็คือ เราจำเป็นต้องระบุจำนวนส่วนประกอบหลัก n_components เป็นอาร์กิวเมนต์ของคลาส PCA ในที่นี้ เราระบุว่าเราต้องการลดมิติของข้อมูลให้เหลือ 1 องค์ประกอบหลัก

เมื่อโมเดลได้รับการฝึกฝนแล้ว เราสามารถใช้เมธอดTransform() เพื่อฉายข้อมูลลงในพื้นที่มิติที่ต่ำกว่าโดยการส่งตัวแปรอินพุตเป็นอาร์กิวเมนต์

นอกจากนี้เรายังสามารถตรวจสอบความแปรปรวนที่อธิบายได้ ซึ่งแสดงถึงสัดส่วนของความแปรปรวนที่อธิบายโดยองค์ประกอบหลักแต่ละส่วน ในตัวอย่างนี้ องค์ประกอบหลักแรกอธิบายความแปรปรวนของข้อมูลได้ 100% ตามที่เราได้ระบุไว้ว่าเราต้องการลดมิติข้อมูลให้เหลือองค์ประกอบหลัก 1 รายการ

เป็นที่น่าสังเกตว่าคุณควรติดตั้งไลบรารี scikit-learn ก่อนที่จะลองใช้มันในโค้ดของคุณ คุณสามารถทำได้โดยการรัน pip install scikit-learn ใน command prompt หรือ terminal

ซี การจัดกลุ่มแบบลำดับชั้น

• คำอธิบายวิธีการทำงานของการจัดกลุ่มแบบลำดับชั้น

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

อัลกอริธึมการจัดกลุ่มแบบลำดับชั้นมีสองประเภทหลัก: การรวมกลุ่มและการแบ่งแยก

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

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

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

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

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

โดยรวมแล้ว การจัดกลุ่มแบบลำดับชั้นถูกนำมาใช้กันอย่างแพร่หลายในการใช้งานหลายอย่าง เช่น การแบ่งส่วนภาพ การวิเคราะห์การแสดงออกของยีน และชีวสารสนเทศศาสตร์

• การใช้งานใน Python โดยใช้ไลบรารี scikit-learn

การจัดกลุ่มแบบลำดับชั้น สามารถนำไปใช้งานได้อย่างง่ายดายใน Python โดยใช้ไลบรารี scikit-learn ไลบรารีมีคลาส AgglomerativeClustering ในตัว ซึ่งสามารถใช้เพื่อสร้างและฝึกอบรมโมเดลการจัดกลุ่มแบบลำดับชั้นแบบกลุ่ม นี่คือตัวอย่างวิธีใช้คลาส AgglomerativeClustering เพื่อจัดกลุ่มชุดข้อมูลออกเป็น 2 คลัสเตอร์:

from sklearn.cluster import AgglomerativeClustering
import numpy as np

# Import data
X = np.array([[1, 2], [2, 3], [3, 4], [4, 5],
             [1, 2], [2, 3], [3, 4], [4, 5]]) # Input variables

# Create and train the agglomerative hierarchical clustering model
agg_clustering = AgglomerativeClustering(n_clusters=2)
agg_clustering.fit(X)

# Predict the cluster for each data point
y_pred = agg_clustering.fit_predict(X)

# Print the cluster labels
print("Cluster labels: ", y_pred)

กระบวนการนี้คล้ายกับตัวอย่างการจัดกลุ่มแบบเคมีน โดยเราจะนำเข้าคลาส AgglomerativeClustering จากโมดูล sklearn.cluster ก่อน จากนั้นเรานำเข้าข้อมูล ในตัวอย่างนี้ เราใช้อาร์เรย์จำนวน 8 จุดข้อมูล

เราสร้างอินสแตนซ์ของคลาส AgglomerativeClustering และเรียกใช้เมธอด fit() เพื่อฝึกโมเดลกับข้อมูล fit() วิธีการรับตัวแปรอินพุตเป็นอาร์กิวเมนต์

สิ่งสำคัญที่ควรทราบคือเราจำเป็นต้องระบุจำนวนคลัสเตอร์ k เป็นอาร์กิวเมนต์ของคลาส AgglomerativeClustering ที่นี่เราระบุว่าเราต้องการจัดกลุ่มข้อมูลออกเป็น 2 คลัสเตอร์

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

เป็นที่น่าสังเกตว่าคุณควรติดตั้งไลบรารี scikit-learn ก่อนที่จะลองใช้มันในโค้ดของคุณ คุณสามารถทำได้โดยการรัน pip install scikit-learn ใน command prompt หรือ terminal นอกจากนี้ ในตัวอย่างนี้ โมเดลการจัดกลุ่มแบบลำดับชั้นจะจัดกลุ่มจุดข้อมูล 4 จุดแรกไว้ด้วยกัน และจัดกลุ่มจุดข้อมูล 4 จุดสุดท้ายไว้ด้วยกันเนื่องจากมีความคล้ายคลึงกันมาก

IV. รูปแบบการเรียนรู้แบบเสริมกำลัง

ก. Q-การเรียนรู้

• คำอธิบายวิธีการทำงานของ Q-learning

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

อัลกอริธึม Q-learning ทำงานโดยการอัปเดตฟังก์ชันมูลค่าการกระทำซ้ำ ๆ โดยอิงตามรางวัลและฟังก์ชันมูลค่าการกระทำโดยประมาณของสถานะถัดไป การอัพเดตทำได้โดยใช้สมการต่อไปนี้:

Q(s,a) = Q(s,a) + α(r + γ max(Q(s', a')) — Q(s,a)) แข็งแกร่ง>

import numpy as np
from keras.models import Sequential
from keras.layers import Dense

# Define the environment
n_states = 4 # Number of states
n_actions = 2 # Number of actions

# Create the Q-network
model = Sequential()
model.add(Dense(10, input_dim=n_states, activation='relu')) # Input layer
model.add(Dense(n_actions, activation='linear')) # Output layer
model.compile(loss='mse', optimizer='adam')

# Define the Q-learning algorithm
epsilon = 0.1 # Exploration rate
alpha = 0.1 # Learning rate
gamma = 0.9 # Discount factor

for episode in range(10000):
    # Initialize the state
    state = np.random.randint(0, n_states)
    done = False
    while not done:
        # Choose an action using an epsilon-greedy policy
        if np.random.rand() < epsilon:
            action = np.random.randint(0, n_actions)
        else:
            action = np.argmax(model.predict(state))
      # Take the action and observe the next state, reward, and done signal
        next_state, reward, done = step(state, action)
        # Update the Q-value using the Q-learning update rule
        target = reward + gamma * np.max(model.predict(next_state))
        target_vec = model.predict(state)
        target_vec[action] = target
        model.fit(state, target_vec, epochs=1, verbose=0)
        # Update the state
        state = next_state

import numpy as np
from keras.models import Sequential
from keras.layers import Dense

# Define the environment
n_states = 4 # Number of states
n_actions = 2 # Number of actions

# Create the Q-network
model = Sequential()
model.add(Dense(10, input_dim=n_states, activation='relu')) # Input layer
model.add(Dense(n_actions, activation='linear')) # Output layer
model.compile(loss='mse', optimizer='adam')

# Define the SARSA algorithm
epsilon = 0.1 # Exploration rate
alpha = 0.1 # Learning rate
gamma = 0.9 # Discount factor

for episode in range(10000):
    # Initialize the state
    state = np.random.randint(0, n_states)
    # Choose an action using an epsilon-greedy policy
    if np.random.rand() < epsilon:
        action = np.random.randint(0, n_actions)
    else:
        action = np.argmax(model.predict(state))
    done = False
    while not done:
      # Take the action and observe the next state, reward, and done signal
        next_state, reward, done = step(state, action)
        # Choose the next action using an epsilon-greedy policy
        if np.random.rand() < epsilon:
            next_action = np.random.randint(0, n_actions)
        else:
            next_action = np.argmax(model.predict(next_state))
        # Update the Q-value using the SARSA update rule
        target = reward + gamma * model.predict(next_state)[0][next_action]
        target_vec = model.predict(state)
        target_vec[action] = target
        model.fit(state, target_vec, epochs=1, verbose=0)
        # Update the state and action
        state = next_state
        action = next_action