הטמעת SVM ו-Kernel SVM עם Scikit-Learn של Python

מבוא

מדריך זה הוא החלק הראשון מתוך שלושה מדריכים בנושא Support Vector Machines (SVMs). בסדרה זו, נעבוד על מקרה שימוש בשטרות מזויפים, נלמד על SVM הפשוטים, לאחר מכן על הפרמטרים של SVM ולבסוף, נלמד מושג שנקרא טריק גרעין ולחקור סוגים אחרים של SVMs.

אם ברצונך לקרוא את כל המדריכים או לראות אילו מהם מעניינים אותך ביותר, להלן טבלת הנושאים המכוסים בכל מדריך:

1. הטמעת SVM ו-Kernel SVM עם Scikit-Learn של Python

• מקרה שימוש: שכח שטרות
• רקע של SVMs
• דגם SVM פשוט (ליניארי).
  • לגבי מערך הנתונים
  • ייבוא ​​מערך הנתונים
  • חקר מערך הנתונים
• הטמעת SVM עם Scikit-Learn
  • חלוקת נתונים לקבוצות רכבת/בדיקות
  • הכשרת המודל
  • להכין תחזיות
  • הערכת המודל
  • פירוש תוצאות

2. הבנת היפרפרמטרים של SVM (בקרוב!)

• היפרפרמטר C
• היפרפרמטר גמא

3. הטמעת טעמי SVM אחרים עם Scikit-Learn של Python (בקרוב!)

• הרעיון הכללי של SVMs (תקציר)
• ליבה (טריק) SVM
• הטמעת SVM ליבה לא ליניארית עם Scikit-Learn
• ייבוא ​​ספריות
  • ייבוא ​​מערך הנתונים
  • חלוקת נתונים לתכונות (X) ויעד (y)
  • חלוקת נתונים לקבוצות רכבת/בדיקות
  • אימון האלגוריתם
• גרעין פולינומי
  • להכין תחזיות
  • הערכת האלגוריתם
• גרעין גאוסי
  • חיזוי והערכה
• קרנל סיגמואיד
  • חיזוי והערכה
• השוואה בין ביצועי ליבה לא לינאריים

מקרה שימוש: שטרות מזויפים

לפעמים אנשים מוצאים דרך לזייף שטרות. אם יש אדם שמסתכל על הפתקים האלה ומוודא את תקפותם, עלול להיות קשה להיות שולל על ידם.

אבל מה קורה כשאין אדם שיסתכל על כל פתק? האם יש דרך לדעת אוטומטית אם שטרות הבנק מזויפים או אמיתיים?

ישנן דרכים רבות לענות על שאלות אלו. תשובה אחת היא לצלם כל פתק שהתקבל, להשוות את התמונה שלו לתמונה של פתק מזויף, ואז לסווג אותו כאמיתי או מזויף. ברגע שזה עשוי להיות מייגע או קריטי לחכות לאימות ההערה, יהיה מעניין גם לבצע את ההשוואה במהירות.

מכיוון שמשתמשים בתמונות, ניתן לדחוס אותן, לצמצם אותן לגווני אפור ולחלץ או לכמת את המדידות שלהן. בדרך זו, ההשוואה תהיה בין מדידות תמונות, במקום הפיקסל של כל תמונה.

עד כה מצאנו דרך לעבד ולהשוות שטרות, אבל איך הם יסווגו לאמיתיים או מזויפים? אנחנו יכולים להשתמש בלמידת מכונה כדי לעשות את הסיווג הזה. יש אלגוריתם סיווג שנקרא תמיכה במכונה וקטורית, הידוע בעיקר בצורתו המקוצרת: SVM.

רקע של SVMs

SVMs הוצגו לראשונה בשנת 1968, על ידי ולדמיר ואפניק ואלכסיי צ'רווננקיס. באותו זמן, האלגוריתם שלהם היה מוגבל לסיווג נתונים שניתן להפריד באמצעות קו ישר אחד בלבד, או נתונים שהיו ניתן להפרדה ליניארית. אנחנו יכולים לראות איך ההפרדה הזו תיראה:

בתמונה שלמעלה יש לנו קו באמצע, שאליו יש נקודות משמאל, ואחרות מימין לקו זה. שימו לב ששתי קבוצות הנקודות מופרדות בצורה מושלמת, אין נקודות ביניהן או אפילו קרובות לקו. נראה שיש מרווח בין נקודות דומות לקו המפריד ביניהן, מרווח זה נקרא שולי הפרדה. תפקידם של שולי ההפרדה הוא להגדיל את הרווח בין הנקודות הדומות לקו המחלק אותן. SVM עושה זאת על ידי שימוש בנקודות מסוימות ומחשב את הווקטורים הניצבים שלו כדי לתמוך בהחלטה על השוליים של הקו. אלה הם תמיכה בוקטורים שהם חלק מהשם של האלגוריתם. נבין עליהם יותר בהמשך. והקו הישר שאנו רואים באמצע נמצא בשיטות ש להגדיל הרווח הזה בין הקו לנקודות, או שממקסמים את שולי ההפרדה. שיטות אלה מקורן בתחום של תורת האופטימיזציה.

בדוגמה שראינו זה עתה, ניתן להפריד את שתי קבוצות הנקודות בקלות, שכן כל נקודה בודדת קרובה לנקודות הדומות לה, ושתי הקבוצות רחוקות זו מזו.

אבל מה קורה אם אין דרך להפריד את הנתונים באמצעות קו ישר אחד? אם יש נקודות מבולגנות שלא במקום, או אם יש צורך בעקומה?

כדי לפתור את הבעיה הזו, SVM שוכלל מאוחר יותר בשנות ה-1990 כדי להיות מסוגל לסווג גם נתונים שיש להם נקודות שהיו רחוקות מהנטייה המרכזית שלו, כמו חריגים, או בעיות מורכבות יותר שהיו להן יותר משני מימדים ולא היו ניתנות להפרדה ליניארית. .

מה שמעניין הוא שרק בשנים האחרונות ה-SVM הפכו לאימוץ נרחב, בעיקר בשל יכולתם להשיג לפעמים יותר מ-90% מהתשובות הנכונות או דיוק, לבעיות קשות.

SVMs מיושמים בצורה ייחודית בהשוואה לאלגוריתמים אחרים של למידת מכונה, ברגע שהם מבוססים על הסברים סטטיסטיים של מהי למידה, או על תורת הלמידה הסטטיסטית.

במאמר זה, נראה מה הם אלגוריתמים של Support Vector Machines, את התיאוריה הקצרה מאחורי מכונת תמיכה וקטורית, והטמעתם בספריית Scikit-Learn של Python. לאחר מכן נתקדם לעבר מושג SVM אחר, המכונה ליבה SVM, או טריק גרעין, וגם יישם אותו בעזרת Scikit-Learn.

דגם SVM פשוט (ליניארי).

לגבי מערך הנתונים

בעקבות הדוגמה שניתנה במבוא, נשתמש במערך נתונים הכולל מדידות של תמונות שטרות כסף אמיתיים ומזויפים.

כשמסתכלים על שני פתקים, העיניים שלנו בדרך כלל סורקות אותם משמאל לימין ובודקות היכן עשויים להיות קווי דמיון או אי דמיון. אנחנו מחפשים נקודה שחורה שמגיעה לפני נקודה ירוקה, או סימן מבריק שנמצא מעל איור. זה אומר שיש סדר שבו אנחנו מסתכלים על ההערות. אם היינו יודעים שיש ירוקים ונקודות שחורות, אבל לא אם הנקודה הירוקה באה לפני השחור, או אם השחור מגיע לפני הירוק, יהיה קשה יותר להבחין בין תווים.

יש שיטה דומה למה שתיארנו זה עתה שניתן ליישם על תמונות השטרות. באופן כללי, שיטה זו מורכבת מתרגום פיקסלים של התמונה לאות, ואז לוקחים בחשבון את הסדר שבו כל אות שונה קורה בתמונה על ידי הפיכתו לגלים קטנים, או גלים. לאחר השגת ה-wavelets, יש דרך לדעת את הסדר שבו אות כלשהו קורה לפני אחר, או את זמן, אבל לא בדיוק איזה אות. כדי לדעת זאת, צריך לקבל את התדרים של התמונה. הם מתקבלים בשיטה שעושה את הפירוק של כל אות, הנקראת שיטת פורייה.

ברגע שמתקבל ממד הזמן דרך הוויילטים, וממד התדר באמצעות שיטת פורייה, מתבצעת העלאה של זמן ותדר כדי לראות מתי לשניהם יש התאמה, זה התפתחות אָנָלִיזָה. הקונבולוציה משיגה התאמה התואמת את הגלי לתדרים של התמונה ומגלה אילו תדרים בולטים יותר.

שיטה זו הכוללת מציאת גלים, התדרים שלהם, ולאחר מכן התאמה לשניהם, נקראת טרנספורמציה של גלים. לטרנספורמציה של הגל יש מקדמים, והמקדמים האלה שימשו כדי להשיג את המדידות שיש לנו במערך הנתונים.

ייבוא ​​מערך הנתונים

מערך הנתונים של שטרות הבנק שבו אנו הולכים להשתמש בסעיף זה זהה לזה שהיה בשימוש בסעיף הסיווג של ה- מדריך עץ החלטות.

בוא נייבא את הנתונים לתוך פנדה dataframe מבנה, ותסתכל על חמש השורות הראשונות שלו עם ה- head() שִׁיטָה.

שימו לב שהנתונים נשמרים ב-a 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 העמודה כוללת את חמש השורות הראשונות שלה ב-0s, או a נבדל ערך.

מכיוון שהמטרה שלנו היא לחזות אם שטר מטבע בנקאי הוא אותנטי או לא, אנו יכולים לעשות זאת על סמך ארבע התכונות של השטר:

• variance של Wavelet Transformed image. בדרך כלל, השונות היא ערך רציף המודד עד כמה נקודות הנתונים קרובות או רחוקות לערך הממוצע של הנתונים. אם הנקודות קרובות יותר לערך הממוצע של הנתונים, ההתפלגות קרובה יותר להתפלגות נורמלית, מה שבדרך כלל אומר שהערכים שלה מפוזרים טוב יותר וקצת יותר קל לנבא. בהקשר התמונה הנוכחי, זוהי השונות של המקדמים הנובעים מהתמרת הגל. ככל שהשונות קטנה יותר, כך המקדמים היו קרובים יותר לתרגום התמונה בפועל.

• skewness של Wavelet Transformed image. ההטיה היא ערך רציף המעיד על אסימטריה של התפלגות. אם יש יותר ערכים משמאל לממוצע, ההתפלגות היא מוטה לרעה, אם יש יותר ערכים מימין לממוצע, ההתפלגות היא מוטה באופן חיובי, ואם הממוצע, המצב והחציון זהים, ההתפלגות היא סימטרי. ככל שהתפלגות סימטרית יותר, כך היא קרובה יותר להתפלגות נורמלית, וגם הערכים שלה מפוזרים טוב יותר. בהקשר הנוכחי, זהו הטיית המקדמים הנובעים מהטרנספורמציה של הגל. ככל שיותר סימטריים, כך המקדמים אנו קרובים יותרvariance, skewness, curtosis, entropyלגבי תרגום התמונה בפועל.

• curtosis (או קורטוזיס) של תמונת Wavelet Transformed. הקורטוזיס הוא ערך מתמשך שכמו הטיה מתאר גם את צורת ההתפלגות. בהתאם למקדם הקורטוזיס (k), התפלגות - בהשוואה להתפלגות הנורמלית יכולה להיות פחות או יותר שטוחה - או שיש לה יותר או פחות נתונים בגפיים או בזנבות שלה. כאשר ההתפלגות מפוזרת יותר ושטוחה יותר, היא נקראת platykurtic; כשהיא פחות פרוסה ויותר מרוכזת באמצע, 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, אז הנתונים שלנו ייחשבו לא מאוזנים, והיינו צריכים לעשות טיפול כלשהו בחוסר איזון, אבל, למרבה המזל, זה לא המקרה.

אנו יכולים גם לראות את ההבדל הזה באופן ויזואלי, על ידי מבט על התפלגות הכיתה או היעד עם היסטוגרמה חדורת פנדה, על ידי שימוש:

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

זה משרטט היסטוגרמה באמצעות מבנה מסגרת הנתונים ישירות, בשילוב עם matplotlib ספרייה שנמצאת מאחורי הקלעים.

על ידי התבוננות בהיסטוגרמה, אנו יכולים להיות בטוחים שערכי היעד שלנו הם 0 או 1 ושהנתונים מאוזנים.

זה היה ניתוח של העמודה שניסינו לחזות, אבל מה לגבי ניתוח העמודות האחרות של הנתונים שלנו?

אנחנו יכולים להסתכל על המדידות הסטטיסטיות עם describe() שיטת dataframe. אנחנו יכולים גם להשתמש .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. מלבד הסתכלות על ההתפלגות, יהיה מעניין לראות כיצד הנקודות של כל מחלקה מופרדות לגבי כל תכונה. לשם כך, נוכל לשרטט עלילת פיזור תוך שילוב של תכונות ביניהן, ולהקצות צבעים שונים לכל נקודה בהתייחס למחלקה שלה.

נתחיל בהתפלגות של כל תכונה, ונתווה את ההיסטוגרמה של כל עמודת נתונים מלבד ה- 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], השתמש ב-Seaborn's 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 של תמיכה בסיווג וקטור or SVC מעמד.

המודל שלנו יקבל את מקדמי ה-wavelet וינסה לסווג אותם על סמך המחלקה. השלב הראשון בתהליך זה הוא להפריד את המקדמים או מאפיינים מהכיתה או יעד. לאחר שלב זה, השלב השני הוא לחלק עוד יותר את הנתונים לסט שישמש ללמידה של המודל או רכבת צעצוע ועוד אחד שישמש להערכת המודל או סט מבחן.

חלוקת נתונים לקבוצות רכבת/בדיקות

בפגישה הקודמת, הבנו וחקרנו את הנתונים. כעת, אנו יכולים לחלק את הנתונים שלנו לשני מערכים - אחד עבור ארבעת התכונות, והשני עבור תכונת היעד החמישית. מכיוון שאנו רוצים לחזות את המחלקה בהתאם למקדמי הגל, שלנו 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 נכס שהוחזר tuple:

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's 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 נתונים, התוצאות מאוחסנות ב-a y_pred מִשְׁתַנֶה. אז כל אחת מהשיעורים החזויים עם מודל SVM הליניארי הפשוט נמצאות כעת ב- y_pred משתנה

זה קוד החיזוי:

y_pred = svc.predict(X_test)

בהתחשב בעובדה שיש לנו את התחזיות, כעת נוכל להשוות אותן לתוצאות בפועל.

הערכת המודל

ישנן מספר דרכים להשוות תחזיות לתוצאות בפועל, והן מודדות היבטים שונים של סיווג. כמה מדדי הסיווג הנפוצים ביותר הם:

1. מטריקס בלבול: כשאנחנו צריכים לדעת כמה דגימות צדקנו או טעינו כל כיתה. הערכים שהיו נכונים וחזויים כהלכה נקראים חיובי אמיתי, אלה שנחזו כחיוביים אך לא היו חיוביים נקראים תוצאות חיוביות שגויות. אותה המינוח של שליליים אמיתיים ו שלילי שווא משמש לערכים שליליים;

2. דיוק: כאשר המטרה שלנו היא להבין אילו ערכי חיזוי נכונים נחשבו נכונים על ידי המסווג שלנו. הדיוק יחלק את אותם ערכים חיוביים אמיתיים בדגימות שנחזו כחיוביות;

$$
דיוק = frac{text{true positives}}{text{true positives} + text{false positives}}
$$

3. להיזכר: בדרך כלל מחושב יחד עם דיוק כדי להבין כמה מהנקודות החיוביות האמיתיות זוהו על ידי המסווג שלנו. ההחזרה מחושבת על ידי חלוקת התוצאות החיוביות האמיתיות בכל מה שהיה צריך לחזות כחיובי.

$$
recall = frac{text{true positives}}{text{true positives} + text{false negatives}}
$$

4. ציון F1: האם המאוזן או ממוצע הרמוני של דיוק וזכירה. הערך הנמוך ביותר הוא 0 והגבוה ביותר הוא 1. מתי f1-score שווה ל-1, זה אומר שכל המחלקות חזו נכון - זה ציון שקשה מאוד להשיג עם נתונים אמיתיים (קיימים כמעט תמיד חריגים).

$$
text{f1-score} = 2* frac{text{precision} * text{recall}}{text{precision} + text{recall}}
$$

כבר הכרנו את מדדי הבלבול, דיוק, היזכרות ומדדי ציון F1. כדי לחשב אותם, נוכל לייבא את של Scikit-Learn metrics סִפְרִיָה. ספרייה זו מכילה את classification_report ו confusion_matrix שיטות, שיטת דוח הסיווג מחזירה את הדיוק, החזרה וציון f1. שניהם classification_report ו confusion_matrix ניתן להשתמש בקלות כדי לגלות את הערכים עבור כל אותם מדדים חשובים.

לחישוב המדדים, אנו מייבאים את השיטות, קוראים להן ומעבירים כטיעונים את הסיווגים החזויים, y_test, ואת תוויות הסיווג, או y_true.

להדמיה טובה יותר של מטריצת הבלבול, נוכל לשרטט אותה ב-Seaborn's 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 יותר נתונים. מה ניתן לעשות בתרחיש זה?

כדי להחזיר את ההתאמה היתרה, נוכל להוסיף עוד תצפיות ברכבת, להשתמש בשיטת אימון עם חלקים שונים של מערך הנתונים, כגון אימות צולב, וגם לשנות את פרמטרי ברירת המחדל שכבר קיימים לפני האימון, בעת יצירת המודל שלנו, או יתר פרמטרים. רוב הזמן, Scikit-learn מגדירה כמה פרמטרים כברירת מחדל, וזה יכול לקרות בשקט אם אין הרבה זמן מוקדש לקריאת התיעוד.

אתה יכול לבדוק את החלק השני של המדריך הזה (בקרוב!) כדי לראות כיצד ליישם אימות צולב ולבצע כוונון היפרפרמטר.

סיכום

במאמר זה למדנו את הגרעין הליניארי הפשוט SVM. קיבלנו את האינטואיציה מאחורי אלגוריתם SVM, השתמשנו במערך נתונים אמיתי, חקרנו את הנתונים וראינו כיצד ניתן להשתמש בנתונים הללו יחד עם SVM על ידי הטמעתם עם ספריית Scikit-Learn של Python.

כדי להמשיך להתאמן, אתה יכול לנסות מערכי נתונים אחרים בעולם האמיתי הזמינים במקומות כמו קגל, UCI, מערכי נתונים ציבוריים של Big Query, אוניברסיטאות ואתרי אינטרנט ממשלתיים.

אני גם מציע שתחקור את המתמטיקה בפועל מאחורי מודל SVM. למרות שאתה לא בהכרח צריך את זה כדי להשתמש באלגוריתם SVM, זה עדיין שימושי מאוד לדעת מה באמת קורה מאחורי הקלעים בזמן שהאלגוריתם שלך מוצא גבולות החלטה.

• הפצת תוכן ויחסי ציבור מופעל על ידי SEO. קבל הגברה היום.
• Platoblockchain. Web3 Metaverse Intelligence. ידע מוגבר. גישה כאן.
• הטבעת העתיד עם אדריאן אשלי. גישה כאן.
• מקור: https://stackabuse.com/implementing-svm-and-kernel-svm-with-pythons-scikit-learn/