การใช้ SVM และ Kernel SVM ด้วย Scikit-Learn ของ Python

บทนำ

คู่มือนี้เป็นส่วนแรกของสามคำแนะนำเกี่ยวกับ Support Vector Machines (SVM) ในซีรีส์นี้ เราจะศึกษากรณีการใช้ธนบัตรปลอม เรียนรู้เกี่ยวกับ SVM แบบง่าย จากนั้นเกี่ยวกับไฮเปอร์พารามิเตอร์ SVM และสุดท้าย เรียนรู้แนวคิดที่เรียกว่า เคล็ดลับเคอร์เนล และสำรวจ SVM ประเภทอื่นๆ

หากคุณต้องการอ่านคู่มือทั้งหมดหรือดูว่าคู่มือใดที่คุณสนใจมากที่สุด ด้านล่างนี้คือตารางหัวข้อที่ครอบคลุมในแต่ละคำแนะนำ:

1. การใช้งาน SVM และ Kernel SVM ด้วย Scikit-Learn ของ Python

• ใช้กรณี: ลืมธนบัตร
• ภูมิหลังของ SVM
• โมเดล SVM แบบง่าย (เชิงเส้น)
  • เกี่ยวกับชุดข้อมูล
  • การนำเข้าชุดข้อมูล
  • สำรวจชุดข้อมูล
• การใช้ SVM กับ Scikit-Learn
  • แบ่งข้อมูลออกเป็นชุดฝึก/ชุดทดสอบ
  • การฝึกโมเดล
  • การทำนายผล
  • การประเมินแบบจำลอง
  • การตีความผลลัพธ์

2. ทำความเข้าใจเกี่ยวกับไฮเปอร์พารามิเตอร์ SVM (เร็ว ๆ นี้!)

• C ไฮเปอร์พารามิเตอร์
• ไฮเปอร์พารามิเตอร์แกมมา

3. การนำรสชาติ SVM อื่นๆ ไปใช้กับ Scikit-Learn ของ Python (เร็ว ๆ นี้!)

• แนวคิดทั่วไปของ SVM (สรุป)
• เคอร์เนล (เคล็ดลับ) SVM
• การใช้ SVM เคอร์เนลแบบไม่เชิงเส้นกับ Scikit-Learn
• การนำเข้าไลบรารี
  • การนำเข้าชุดข้อมูล
  • แบ่งข้อมูลออกเป็นคุณลักษณะ (X) และเป้าหมาย (y)
  • แบ่งข้อมูลออกเป็นชุดฝึก/ชุดทดสอบ
  • การฝึกอบรมอัลกอริทึม
• เคอร์เนลพหุนาม
  • การทำนายผล
  • การประเมินอัลกอริทึม
• เมล็ดเกาส์เซียน
  • การทำนายและประเมินผล
• เคอร์เนลซิกมอยด์
  • การทำนายและประเมินผล
• การเปรียบเทียบประสิทธิภาพของเคอร์เนลที่ไม่ใช่เชิงเส้น

กรณีการใช้งาน: ธนบัตรปลอม

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

แต่จะเกิดอะไรขึ้นเมื่อไม่มีคนดูโน้ตแต่ละตัว? มีวิธีที่จะทราบโดยอัตโนมัติว่าธนบัตรเป็นของปลอมหรือของจริงหรือไม่?

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

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

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

ภูมิหลังของ SVM

SVM ถูกนำมาใช้ครั้งแรกในปี 1968 โดย Vladmir Vapnik และ Alexey Chervonenkis ในเวลานั้น อัลกอริทึมของพวกเขาถูกจำกัดให้จัดหมวดหมู่ข้อมูลที่สามารถแยกโดยใช้เส้นตรงเส้นเดียวหรือข้อมูลที่แยกจากกัน แยกเชิงเส้นได้. เราสามารถเห็นได้ว่าการแยกนั้นมีลักษณะอย่างไร:

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

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

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

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

สิ่งที่น่าสงสัยคือในช่วงไม่กี่ปีที่ผ่านมา SVM ได้รับการยอมรับอย่างกว้างขวาง สาเหตุหลักมาจากความสามารถในการบรรลุคำตอบที่ถูกต้องมากกว่า 90% ในบางครั้งหรือ ความถูกต้องสำหรับปัญหาที่ยาก

SVM ถูกนำมาใช้ในลักษณะที่ไม่เหมือนใครเมื่อเปรียบเทียบกับอัลกอริธึมการเรียนรู้ของเครื่องอื่นๆ เมื่ออิงตามคำอธิบายทางสถิติว่าการเรียนรู้คืออะไร หรือบน ทฤษฎีการเรียนรู้ทางสถิติ.

ในบทความนี้ เราจะมาดูกันว่าอัลกอริทึมของ Support Vector Machines คืออะไร ทฤษฎีโดยย่อที่อยู่เบื้องหลังเครื่องเวกเตอร์สนับสนุน และการนำไปใช้ในไลบรารี Scikit-Learn ของ Python จากนั้นเราจะไปสู่แนวคิด SVM อื่นที่เรียกว่า เคอร์เนล SVM,หรือ เคล็ดลับเคอร์เนลและจะนำไปใช้ด้วยความช่วยเหลือของ Scikit-Learn

โมเดล SVM แบบง่าย (เชิงเส้น)

เกี่ยวกับชุดข้อมูล

ตามตัวอย่างที่ให้ไว้ในบทนำ เราจะใช้ชุดข้อมูลที่มีภาพธนบัตรจริงและธนบัตรปลอม

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

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

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

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

การนำเข้าชุดข้อมูล

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

ลองนำเข้าข้อมูลไปยังหมีแพนด้า dataframe โครงสร้าง และดูห้าแถวแรกด้วยเครื่องหมาย head() วิธี

สังเกตว่าข้อมูลจะถูกบันทึกไว้ใน txt (ข้อความ) รูปแบบไฟล์ คั่นด้วยเครื่องหมายจุลภาค และไม่มีส่วนหัว เราสามารถสร้างใหม่เป็นตารางโดยอ่านเป็น csv, ระบุ separator เป็นลูกน้ำและเพิ่มชื่อคอลัมน์ด้วย names ข้อโต้แย้ง.

ทำตามสามขั้นตอนพร้อมกัน จากนั้นดูข้อมูลห้าแถวแรก:

import pandas as pd data_link = "https://archive.ics.uci.edu/ml/machine-learning-databases/00267/data_banknote_authentication.txt"
col_names = ["variance", "skewness", "curtosis", "entropy", "class"] bankdata = pd.read_csv(data_link, names=col_names, sep=",", header=None)
bankdata.head()

ผลลัพธ์นี้ใน:

	variance skewness curtosis entropy class
0 3.62160 8.6661 -2.8073 -0.44699 0
1 4.54590 8.1674 -2.4586 -1.46210 0
2 3.86600 -2.6383 1.9242 0.10645 0
3 3.45660 9.5228 -4.0112 -3.59440 0
4 0.32924 -4.4552 4.5718 -0.98880 0

เราจะเห็นว่ามีห้าคอลัมน์ในชุดข้อมูลของเรา ได้แก่ variance, skewness, curtosis, entropyและ class. ในห้าแถว สี่คอลัมน์แรกจะเต็มไปด้วยตัวเลข เช่น 3.62160, 8.6661, -2.8073 หรือ ต่อเนื่องกัน ค่าและสุดท้าย class คอลัมน์มีห้าแถวแรกที่เต็มไปด้วย 0 หรือ a ที่ไม่ต่อเนื่อง มูลค่า

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

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

• skewness ของภาพที่แปลงเวฟเล็ต ความเบ้คือค่าต่อเนื่องที่ระบุความไม่สมดุลของการกระจาย ถ้ามีค่ามากกว่าทางด้านซ้ายของค่าเฉลี่ย แสดงว่ามีการแจกแจง เบ้ในทางลบถ้ามีค่ามากกว่าทางด้านขวาของค่าเฉลี่ย แสดงว่ามีการแจกแจง เบ้ในเชิงบวกและถ้าค่าเฉลี่ย ฐานนิยม และมัธยฐานเท่ากัน การกระจายจะเป็น สมมาตร. ยิ่งการแจกแจงแบบสมมาตรมากเท่าใด การแจกแจงแบบปกติก็จะยิ่งใกล้เคียงกับการแจกแจงแบบปกติมากขึ้นเท่านั้น ในบริบทปัจจุบัน นี่คือความเบ้ของค่าสัมประสิทธิ์ที่เป็นผลมาจากการแปลงเวฟเล็ต ยิ่งมีความสมมาตรมากเท่าใด ค่าสัมประสิทธิ์ก็จะยิ่งเข้าใกล้เรามากขึ้นเท่านั้นvariance, skewness, curtosis, entropyอีกครั้งเพื่อแปลภาพจริง

• curtosis (หรือความโด่ง) ของรูปภาพ Wavelet Transformed ความโด่งเป็นค่าต่อเนื่องที่อธิบายรูปร่างของการกระจายเช่นเดียวกับความเบ้ ขึ้นอยู่กับค่าสัมประสิทธิ์เคิร์ตซีส (k) การแจกแจง - เมื่อเปรียบเทียบกับการแจกแจงแบบปกติอาจแบนมากหรือน้อยกว่านี้ - หรือมีข้อมูลในส่วนปลายหรือส่วนปลายมากหรือน้อย เมื่อความหน่ายยิ่งแผ่ออกไปจนราบเป็นหน้ากลอง ก็เรียก แพลทิเคิร์ติค; เมื่อกระจายออกน้อยลงและเข้มข้นขึ้นตรงกลาง เมโสเคอร์ติก; และเมื่อการกระจายนั้นกระจุกตัวอยู่ตรงกลางเกือบทั้งหมด ก็เรียกว่า เลปโตเคอร์ติค. นี่เป็นกรณีเดียวกับความแปรปรวนและความเบ้กรณีก่อนหน้า ยิ่งมีการกระจายตัวแบบ mesokurtic มากเท่าไหร่ ค่าสัมประสิทธิ์ก็จะยิ่งใกล้เคียงกับการแปลภาพจริงมากขึ้นเท่านั้น

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

ตัวแปรที่ห้าคือ class ตัวแปร ซึ่งอาจมีค่า 0 และ 1 ที่บอกว่าโน้ตนั้นเป็นของจริงหรือของปลอม

เราสามารถตรวจสอบว่าคอลัมน์ที่ห้ามีเลขศูนย์และคอลัมน์ที่มี Pandas ' unique() วิธี:

bankdata['class'].unique()

วิธีการข้างต้นส่งคืน:

array([0, 1]) 

เมธอดด้านบนจะคืนค่าอาร์เรย์ที่มีค่า 0 และ 1 ซึ่งหมายความว่าค่าที่มีอยู่ในแถวของคลาสของเราคือศูนย์และค่าเดียว พร้อมใช้เป็น เป้า ในการเรียนรู้แบบมีผู้สอนของเรา

• class ของภาพ นี่คือค่าจำนวนเต็ม โดยเป็น 0 เมื่อรูปภาพถูกปลอมแปลง และ 1 เมื่อรูปภาพเป็นของจริง

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

เรายังสามารถดูจำนวนระเบียนหรือภาพที่เรามี โดยดูที่จำนวนแถวในข้อมูลผ่านทาง shape คุณสมบัติ:

bankdata.shape

ผลลัพธ์นี้:

(1372, 5)

บรรทัดด้านบนหมายความว่ามีรูปภาพธนบัตรที่แปลงแล้ว 1,372 แถว และ 5 คอลัมน์ นี่คือข้อมูลที่เราจะวิเคราะห์

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

สำรวจชุดข้อมูล

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

หากต้องการทราบสัดส่วน เราสามารถนับแต่ละค่าศูนย์และค่าเดียวในข้อมูลได้ value_counts() วิธี:

bankdata['class'].value_counts()

ผลลัพธ์นี้:

0 762
1 610
Name: class, dtype: int64

จากผลลัพธ์ข้างต้น เราจะเห็นว่ามีเลขศูนย์ 762 ตัวและเลขหนึ่ง 610 ตัว หรือเลขศูนย์มากกว่าเลขหนึ่ง 152 ตัว ซึ่งหมายความว่าเราได้ปลอมแปลงรูปภาพจริงมากขึ้นอีกเล็กน้อย และหากความคลาดเคลื่อนนั้นใหญ่ขึ้น เช่น 5500 ศูนย์และ 610 อัน อาจส่งผลเสียต่อผลลัพธ์ของเรา เมื่อเราพยายามใช้ตัวอย่างเหล่านั้นในโมเดลของเรา ยิ่งมีตัวอย่างมากเท่าไร มักจะหมายความว่าโมเดลจะต้องใช้ข้อมูลมากขึ้นในการตัดสินใจระหว่างโน้ตปลอมหรือโน้ตจริง หากมีตัวอย่างโน้ตจริงน้อย โมเดลมีแนวโน้มที่จะเป็น เข้าใจผิดเมื่อพยายามจดจำพวกเขา

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

ขั้นตอนแรกคือการใช้แพนด้า value_counts() วิธีการอีกครั้ง แต่ตอนนี้มาดูเปอร์เซ็นต์โดยรวมอาร์กิวเมนต์ normalize=True:

bankdata['class'].value_counts(normalize=True)

พื้นที่ normalize=True คำนวณเปอร์เซ็นต์ของข้อมูลสำหรับแต่ละชั้นเรียน จนถึงตอนนี้ เปอร์เซ็นต์ของการปลอมแปลง (0) และข้อมูลจริง (1) คือ:

0 0.555394
1 0.444606
Name: class, dtype: float64

ซึ่งหมายความว่าประมาณ (~) 56% ของชุดข้อมูลของเราถูกปลอมแปลงและ 44% เป็นของจริง นี่ทำให้เรามีอัตราส่วน 56%-44% ซึ่งเท่ากับความแตกต่าง 12% ซึ่งในทางสถิติถือว่ามีความแตกต่างเล็กน้อย เนื่องจากมีค่ามากกว่า 10% เล็กน้อย ดังนั้นข้อมูลจึงถือว่าสมดุล หากแทนที่จะเป็นสัดส่วน 56:44 มีสัดส่วน 80:20 หรือ 70:30 ข้อมูลของเราจะถือว่าไม่สมดุล และเราจำเป็นต้องดำเนินการแก้ไขความไม่สมดุล แต่โชคดีที่ไม่เป็นเช่นนั้น

นอกจากนี้ เรายังสามารถมองเห็นความแตกต่างนี้ได้ด้วยสายตา โดยดูที่การกระจายของคลาสหรือเป้าหมายด้วยฮิสโทแกรมของ Pandas โดยใช้:

bankdata['class'].plot.hist();

สิ่งนี้จะพล็อตฮิสโตแกรมโดยใช้โครงสร้างดาต้าเฟรมโดยตรง ร่วมกับ matplotlib ห้องสมุดที่อยู่เบื้องหลัง

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

นี่คือการวิเคราะห์คอลัมน์ที่เราพยายามทำนาย แต่การวิเคราะห์คอลัมน์อื่นๆ ของข้อมูลของเราล่ะ

เราสามารถดูการวัดทางสถิติด้วย describe() วิธีการดาต้าเฟรม เรายังสามารถใช้ .T ของทรานสโพส – เพื่อสลับคอลัมน์และแถว ทำให้เปรียบเทียบระหว่างค่าต่างๆ ได้โดยตรงมากขึ้น:

bankdata.describe().T

ผลลัพธ์นี้ใน:

 count mean std min 25% 50% 75% max
variance 1372.0 0.433735 2.842763 -7.0421 -1.773000 0.49618 2.821475 6.8248
skewness 1372.0 1.922353 5.869047 -13.7731 -1.708200 2.31965 6.814625 12.9516
curtosis 1372.0 1.397627 4.310030 -5.2861 -1.574975 0.61663 3.179250 17.9274
entropy 1372.0 -1.191657 2.101013 -8.5482 -2.413450 -0.58665 0.394810 2.4495
class 1372.0 0.444606 0.497103 0.0000 0.000000 0.00000 1.000000 1.0000

ขอให้สังเกตว่าคอลัมน์ความเบ้และโค้งงอมีค่าเฉลี่ยที่ห่างจากค่าส่วนเบี่ยงเบนมาตรฐาน ซึ่งบ่งชี้ว่าค่าเหล่านั้นอยู่ห่างจากแนวโน้มเข้าสู่ศูนย์กลางของข้อมูล หรือมีความแปรปรวนมากกว่า

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

เรามาเริ่มกันที่การกระจายของคุณลักษณะแต่ละรายการ และวางแผนกราฟฮิสโตแกรมของข้อมูลแต่ละคอลัมน์ ยกเว้น class คอลัมน์. class คอลัมน์จะไม่ถูกนำมาพิจารณาโดยตำแหน่งในอาร์เรย์คอลัมน์ข้อมูลธนาคาร คอลัมน์ทั้งหมดจะถูกเลือก ยกเว้นคอลัมน์สุดท้ายที่มี columns[:-1]:

import matplotlib.pyplot as plt for col in bankdata.columns[:-1]: plt.title(col) bankdata[col].plot.hist() plt.show();

หลังจากเรียกใช้โค้ดด้านบน เราจะเห็นว่าทั้งสอง skewness และ entropy การกระจายข้อมูลเบ้ในเชิงลบและ curtosis มีความเบ้ในเชิงบวก การแจกแจงทั้งหมดเป็นแบบสมมาตรและ variance เป็นการกระจายเดียวที่ใกล้เคียงปกติ

ตอนนี้เราสามารถไปยังส่วนที่สองและพล็อตกระจายของแต่ละตัวแปร ในการทำเช่นนี้ เรายังสามารถเลือกคอลัมน์ทั้งหมดยกเว้นชั้นเรียนได้ด้วย columns[:-1]ให้ใช้ของซีบอร์น scatterplot() และสองสำหรับลูปเพื่อให้ได้รูปแบบในการจับคู่สำหรับแต่ละคุณสมบัติ นอกจากนี้ เรายังสามารถยกเว้นการจับคู่คุณลักษณะกับตัวมันเอง โดยทดสอบว่าคุณลักษณะแรกเท่ากับคุณลักษณะที่สองด้วยเครื่องหมาย if statement.

import seaborn as sns for feature_1 in bankdata.columns[:-1]: for feature_2 in bankdata.columns[:-1]: if feature_1 != feature_2: print(feature_1, feature_2) sns.scatterplot(x=feature_1, y=feature_2, data=bankdata, hue='class') plt.show();

สังเกตว่ากราฟทั้งหมดมีจุดข้อมูลทั้งจริงและปลอมซึ่งไม่ได้แยกออกจากกันอย่างชัดเจน ซึ่งหมายความว่ามีคลาสซ้อนทับบางประเภท เนื่องจากโมเดล SVM ใช้เส้นแบ่งระหว่างคลาส กลุ่มใดในกราฟสามารถแยกออกโดยใช้บรรทัดเดียวได้หรือไม่ ดูเหมือนไม่น่าเป็นไปได้ นี่คือลักษณะของข้อมูลจริงส่วนใหญ่ สิ่งที่ใกล้เคียงที่สุดที่เราสามารถแยกแยะได้คือการรวมกันของ skewness และ variance,หรือ entropy และ variance แปลง ทั้งนี้น่าจะเกิดจาก variance ข้อมูลที่มีรูปร่างการกระจายที่ใกล้เคียงกับปกติ

แต่การดูกราฟทั้งหมดตามลำดับอาจเป็นเรื่องยากเล็กน้อย เรามีทางเลือกในการดูกราฟการกระจายและกระจายทั้งหมดร่วมกันโดยใช้ของ Seaborn pairplot().

ทั้งสองลูปก่อนหน้าที่เราทำสามารถแทนที่ได้ด้วยบรรทัดนี้:

sns.pairplot(bankdata, hue='class');

ดูพล็อตคู่แล้วดูเหมือนว่าจริง ๆ แล้ว curtosis และ variance จะเป็นการผสมผสานคุณสมบัติที่ง่ายที่สุด ดังนั้นคลาสต่างๆ สามารถคั่นด้วยบรรทัด หรือ แยกเชิงเส้นได้.

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

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

การใช้ SVM กับ Scikit-Learn

ก่อนที่จะเข้าใจมากขึ้นเกี่ยวกับทฤษฎีการทำงานของ SVM เราสามารถสร้างแบบจำลองพื้นฐานแรกของเราด้วยข้อมูล และ Scikit-Learn's สนับสนุนตัวแยกประเภทเวกเตอร์ or SVC ชั้นเรียน

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

แบ่งข้อมูลออกเป็นชุดฝึก/ชุดทดสอบ

ในตอนที่แล้ว เราได้ทำความเข้าใจและสำรวจข้อมูล ตอนนี้ เราสามารถแบ่งข้อมูลออกเป็นสองอาร์เรย์ – หนึ่งสำหรับสี่คุณลักษณะ และอีกส่วนหนึ่งสำหรับคุณลักษณะที่ห้า หรือเป้าหมาย เนื่องจากเราต้องการทำนายคลาสโดยขึ้นอยู่กับค่าสัมประสิทธิ์ของเวฟเล็ต y จะเป็น class คอลัมน์และของเรา X จะ variance, skewness, curtosisและ entropy คอลัมน์

ในการแยกเป้าหมายและคุณสมบัติ เราสามารถระบุได้เฉพาะ class คอลัมน์ถึง yภายหลังปล่อยจาก dataframe เพื่อระบุคอลัมน์ที่เหลือ X กับ .drop() วิธี:

y = bankdata['class']
X = bankdata.drop('class', axis=1) 

เมื่อแบ่งข้อมูลออกเป็นแอตทริบิวต์และป้ายกำกับแล้ว เราก็สามารถแบ่งข้อมูลออกเป็นชุดฝึกและชุดทดสอบได้ ซึ่งสามารถทำได้ด้วยมือ แต่ model_selection ไลบรารีของ Scikit-Learn ประกอบด้วย train_test_split() วิธีที่ช่วยให้เราสุ่มแบ่งข้อมูลออกเป็นชุดรถไฟและชุดทดสอบ

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

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

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

คุณสามารถเรียกใช้สคริปต์ต่อไปนี้:

from sklearn.model_selection import train_test_split SEED = 42 X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.20, random_state = SEED)

ขอให้สังเกตว่า train_test_split() เมธอดส่งคืนไฟล์ X_train, X_test, y_train, y_test กำหนดตามลำดับนี้ เราสามารถพิมพ์จำนวนตัวอย่างที่แยกสำหรับรถไฟและทดสอบโดยรับองค์ประกอบแรก (0) ของ shape คุณสมบัติที่ส่งคืนทูเพิล:

xtrain_samples = X_train.shape[0]
xtest_samples = X_test.shape[0] print(f'There are {xtrain_samples} samples for training and {xtest_samples} samples for testing.')

นี่แสดงให้เห็นว่ามี 1097 ตัวอย่างสำหรับการฝึกอบรมและ 275 สำหรับการทดสอบ

การฝึกโมเดล

เราได้แบ่งข้อมูลออกเป็นชุดฝึกและชุดทดสอบ ถึงเวลาสร้างและฝึกโมเดล SVM บนข้อมูลรถไฟแล้ว ในการทำเช่นนั้น เราสามารถนำเข้า Scikit-Learn svm ห้องสมุดพร้อมกับ สนับสนุนตัวแยกประเภทเวกเตอร์ ชั้นหรือ SVC ชั้นเรียน

หลังจากอิมพอร์ตคลาสแล้ว เราสามารถสร้างอินสแตนซ์ของมันได้ เนื่องจากเรากำลังสร้างโมเดล SVM อย่างง่าย เราจึงพยายามแยกข้อมูลออกเป็นเชิงเส้น ดังนั้นเราจึงสามารถลากเส้นเพื่อแบ่งข้อมูล ซึ่งเหมือนกับการใช้ ฟังก์ชันเชิงเส้น – โดยการกำหนด kernel='linear' เป็นอาร์กิวเมนต์สำหรับลักษณนาม:

from sklearn.svm import SVC
svc = SVC(kernel='linear')

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

เราสามารถรันโค้ดต่อไปนี้เพื่อฝึกโมเดล:

svc.fit(X_train, y_train)

เช่นเดียวกับที่โมเดลได้รับการฝึกฝน จนถึงตอนนี้ เราได้ทำความเข้าใจข้อมูล แบ่งข้อมูล สร้างโมเดล SVM อย่างง่าย และติดตั้งโมเดลเข้ากับข้อมูลรถไฟ

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

การทำนายผล

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

เมื่อพิจารณาว่าการเรียนรู้ถูกควบคุม เราสามารถคาดการณ์ได้ด้วย X_test และเปรียบเทียบผลการทำนายเหล่านั้น – ซึ่งเราอาจเรียกว่า y_pred – กับของจริง y_test,หรือ ความจริงพื้นดิน.

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

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

นี่คือรหัสทำนาย:

y_pred = svc.predict(X_test)

เมื่อพิจารณาจากการคาดการณ์แล้ว เราก็สามารถเปรียบเทียบผลลัพธ์เหล่านี้กับผลลัพธ์จริงได้

การประเมินแบบจำลอง

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

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

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

$$
ความแม่นยำ = frac{ข้อความ{ผลบวกจริง}}{ข้อความ{ผลบวกจริง} + ข้อความ{ผลบวกเท็จ}}
$$

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

$$
เรียกคืน = frac{ข้อความ{ผลบวกจริง}}{ข้อความ{ผลบวกจริง} + ข้อความ{ผลลบเท็จ}}
$$

4. คะแนน F1: คือความสมดุลหรือ ฮาร์โมนิก ของความแม่นยำและการเรียกคืน ค่าต่ำสุดคือ 0 และค่าสูงสุดคือ 1 เมื่อ f1-score เท่ากับ 1 หมายความว่าทุกคลาสได้รับการทำนายอย่างถูกต้อง – นี่เป็นคะแนนที่ยากมากที่จะได้รับจากข้อมูลจริง (มีข้อยกเว้นเกือบทุกครั้ง)

$$
ข้อความ{f1-score} = 2* frac{text{precision} * text{recall}}{text{precision} + text{recall}}
$$

เราคุ้นเคยกับเมทริกซ์ความสับสน ความแม่นยำ การเรียกคืน และการวัดคะแนน F1 แล้ว ในการคำนวณ เราสามารถนำเข้า Scikit-Learn's metrics ห้องสมุด. ห้องสมุดนี้ประกอบด้วย classification_report และ confusion_matrix วิธีการ วิธีการรายงานการจัดประเภทจะส่งกลับค่าความแม่นยำ การเรียกคืน และคะแนน f1 ทั้งคู่ classification_report และ confusion_matrix สามารถใช้เพื่อค้นหาค่าสำหรับเมตริกที่สำคัญเหล่านั้นทั้งหมดได้อย่างง่ายดาย

สำหรับการคำนวณเมตริก เรานำเข้าเมธอด เรียกใช้และส่งผ่านอาร์กิวเมนต์ไปยังการจัดประเภทที่คาดการณ์ไว้ y_testและฉลากแยกประเภท หรือ y_true.

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

from sklearn.metrics import classification_report, confusion_matrix cm = confusion_matrix(y_test,y_pred)
sns.heatmap(cm, annot=True, fmt='d').set_title('Confusion matrix of linear SVM') print(classification_report(y_test,y_pred))

สิ่งนี้แสดง:

 precision recall f1-score support 0 0.99 0.99 0.99 148 1 0.98 0.98 0.98 127 accuracy 0.99 275 macro avg 0.99 0.99 0.99 275
weighted avg 0.99 0.99 0.99 275

ในรายงานการจำแนกประเภท เราทราบว่ามีความแม่นยำ 0.99 การเรียกคืน 0.99 และคะแนน f1 0.99 สำหรับธนบัตรปลอมหรือคลาส 0 การวัดเหล่านั้นได้มาจากตัวอย่าง 148 ตัวอย่างตามที่แสดงในคอลัมน์สนับสนุน ในขณะเดียวกัน สำหรับคลาส 1 หรือบันทึกจริง ผลลัพธ์คือหนึ่งหน่วยด้านล่าง ความแม่นยำ 0.98 การเรียกคืน 0.98 และคะแนน f1 เท่าเดิม ในครั้งนี้ มีการใช้การวัดภาพ 127 ภาพเพื่อให้ได้ผลลัพธ์เหล่านั้น

หากเราดูเมทริกซ์ความสับสน เราจะเห็นว่าจากตัวอย่างคลาส 148 จำนวน 0 ตัวอย่าง จำแนกได้ถูกต้อง 146 รายการ และมีผลบวกปลอม 2 รายการ ในขณะที่ตัวอย่างระดับ 127 จำนวน 1 ตัวอย่าง มีผลลบลวง 2 รายการ และผลบวกจริง 125 รายการ

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

การตีความผลลัพธ์

หากต้องการทราบความหมาย ให้ดูที่เมตริกทั้งหมดรวมกัน

ตัวอย่างเกือบทั้งหมดสำหรับคลาส 1 ถูกจำแนกอย่างถูกต้อง มีข้อผิดพลาด 2 ข้อสำหรับแบบจำลองของเราเมื่อระบุธนบัตรจริง ซึ่งเหมือนกับการเรียกคืน 0.98 หรือ 98% สิ่งที่คล้ายกันอาจกล่าวได้ว่าเป็นคลาส 0 มีเพียง 2 ตัวอย่างเท่านั้นที่จัดประเภทไม่ถูกต้อง ในขณะที่ 148 เป็นค่าเนกาทีฟจริง รวมความแม่นยำ 99%

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

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

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

ในการทำนายด้วยข้อมูลรถไฟ เราสามารถทำซ้ำสิ่งที่เราทำกับข้อมูลทดสอบ แต่ตอนนี้ใช้ X_train:

y_pred_train = svc.predict(X_train) cm_train = confusion_matrix(y_train,y_pred_train)
sns.heatmap(cm_train, annot=True, fmt='d').set_title('Confusion matrix of linear SVM with train data') print(classification_report(y_train,y_pred_train))

ผลลัพธ์นี้:

 precision recall f1-score support 0 0.99 0.99 0.99 614 1 0.98 0.99 0.99 483 accuracy 0.99 1097 macro avg 0.99 0.99 0.99 1097
weighted avg 0.99 0.99 0.99 1097

ดูเหมือนว่าจะเกินพอดีได้ง่ายๆ เมื่อเมตริกรถไฟอยู่ที่ 99% เมื่อมีข้อมูลมากขึ้น 4 เท่า สิ่งที่สามารถทำได้ในสถานการณ์นี้?

หากต้องการคืนค่า overfit เราสามารถเพิ่มการสังเกตรถไฟ ใช้วิธีการฝึกอบรมกับส่วนต่างๆ ของชุดข้อมูล เช่น การตรวจสอบข้ามและยังเปลี่ยนพารามิเตอร์เริ่มต้นที่มีอยู่แล้วก่อนการฝึกอบรม เมื่อสร้างแบบจำลองของเรา หรือ ไฮเปอร์พารามิเตอร์. โดยส่วนใหญ่แล้ว Scikit-learn จะตั้งค่าพารามิเตอร์บางตัวเป็นค่าเริ่มต้น และสิ่งนี้อาจเกิดขึ้นอย่างเงียบ ๆ หากไม่มีเวลามากพอที่จะอ่านเอกสารประกอบ

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

สรุป

ในบทความนี้ เราศึกษา SVM เคอร์เนลเชิงเส้นอย่างง่าย เรามีสัญชาตญาณที่อยู่เบื้องหลังอัลกอริทึม SVM ใช้ชุดข้อมูลจริง สำรวจข้อมูล และเห็นว่าข้อมูลนี้สามารถใช้ร่วมกับ SVM ได้อย่างไรโดยใช้งานกับไลบรารี Scikit-Learn ของ Python

ในการฝึกฝน คุณสามารถลองใช้ชุดข้อมูลจริงอื่นๆ ที่มีอยู่ในสถานที่ต่างๆ เช่น Kaggle, UCI, ชุดข้อมูลสาธารณะของ Big Queryมหาวิทยาลัย และเว็บไซต์ของรัฐบาล

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

• เนื้อหาที่ขับเคลื่อนด้วย SEO และการเผยแพร่ประชาสัมพันธ์ รับการขยายวันนี้
• เพลโตบล็อคเชน Web3 Metaverse ข่าวกรอง ขยายความรู้. เข้าถึงได้ที่นี่.
• การสร้างอนาคตโดย Adryenn Ashley เข้าถึงได้ที่นี่.
• ที่มา: https://stackabuse.com/implementing-svm-and-kernel-svm-with-pythons-scikit-learn/