הטמעת טעמי SVM אחרים עם Scikit-Learn של Python

מבוא

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

בסדרה המלאה של מדריכי SVM, מלבד למידה על סוגים אחרים של SVMs, תלמדו גם על SVM פשוטים, SVM-פרמטרים מוגדרים מראש, C ו-Gamma היפרפרמטרים וכיצד ניתן לכוונן אותם באמצעות חיפוש רשת ואימות צולב.

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

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 לפני שנראה כמה וריאציות מעניינות של ליבת SVM.

הרעיון הכללי של SVMs

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

איור 1: גבולות החלטות מרובים

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

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

איור 2: גבול החלטה עם וקטורי תמיכה

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

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

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

ליבה (טריק) SVM

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

איור 3: נתונים שאינם ניתנים להפרדה באופן ליניארי

במקום זאת, אנו יכולים להשתמש בגרסה המעודכנת של SVM שדיברנו עליה בהתחלה, שנקראת Kernel SVM.

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

הטמעת ליבה לא ליניארית SVM עם Scikit-Learn

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

אתה תראה ששאר השלבים הם שלבי למידת מכונה אופייניים וצריכים מעט מאוד הסבר עד שנגיע לחלק שבו אנו מאמנים את ה-SVM ה-Non-linear Kernel SVM שלנו.

יבוא ספריות

import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
import seaborn as sns
from sklearn.model_selection import train_test_split

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

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()mes)

חלוקת נתונים לתכונות (X) ויעד (y)

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

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

SEED = 42 X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.20, random_state = SEED)

אימון האלגוריתם

כדי לאמן את הגרעין SVM, נשתמש באותו SVC כיתת ה-Skikit-Learn's svm סִפְרִיָה. ההבדל טמון בערך של פרמטר הליבה של ה- SVC מעמד.

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

1. גרעין פולינום

באלגברה, פולינום הוא ביטוי של הצורה:

$$
2a*b^3 + 4a – 9
$$

יש לזה משתנים, כמו a ו b, קבועים, בדוגמה שלנו, 9 ומקדמים (קבועים המלווים במשתנים), כגון 2 ו 4. ה 3 נחשב לדרגת הפולינום.

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

אז, ליישום ה גרעין פולינום, מלבד בחירת ה poly קרנל, נעביר גם ערך עבור ה degree פרמטר של SVC מעמד. להלן הקוד:

from sklearn.svm import SVC
svc_poly = SVC(kernel='poly', degree=8)
svc_poly.fit(X_train, y_train)

להכין תחזיות

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

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

y_pred_poly = svclassifier.predict(X_test)

הערכת האלגוריתם

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

def display_results(y_test, y_pred, cm_title): cm = confusion_matrix(y_test,y_pred) sns.heatmap(cm, annot=True, fmt='d').set_title(cm_title) print(classification_report(y_test,y_pred))

כעת, אנו יכולים לקרוא לפונקציה ולהסתכל על התוצאות שהתקבלו עם ליבת הפולינום:

cm_title_poly = "Confusion matrix with polynomial kernel"
display_results(y_test, y_pred_poly, cm_title_poly)

הפלט נראה כך:

 precision recall f1-score support 0 0.69 1.00 0.81 148 1 1.00 0.46 0.63 127 accuracy 0.75 275 macro avg 0.84 0.73 0.72 275
weighted avg 0.83 0.75 0.73 275

כעת נוכל לחזור על אותם שלבים עבור גרעיני גאוס וסיגמואידים.

2. גרעין גאוסי

כדי להשתמש בקרנל גאוסי, אנחנו צריכים רק לציין 'rbf' כערך עבור ה- kernel פרמטר של מחלקת SVC:

svc_gaussian = SVC(kernel='rbf', degree=8)
svc_gaussian.fit(X_train, y_train)

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

חיזוי והערכה

y_pred_gaussian = svc_gaussian.predict(X_test)

cm_title_gaussian = "Confusion matrix with Gaussian kernel"
display_results(y_test, y_pred_gaussian, cm_title_gaussian)

הפלט של SVM הגרעין גאוסי נראה כך:

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

3. קרנל סיגמואיד

לבסוף, בואו נשתמש בקרנל סיגמואיד ליישום Kernel SVM. תסתכל על התסריט הבא:

svc_sigmoid = SVC(kernel='sigmoid')
svc_sigmoid.fit(X_train, y_train)

כדי להשתמש בליבת הסיגמואיד, עליך לציין 'סיגמואיד' כערך עבור ה- kernel פרמטר של SVC מעמד.

חיזוי והערכה

y_pred_sigmoid = svc_sigmoid.predict(X_test)

cm_title_sigmoid = "Confusion matrix with Sigmoid kernel"
display_results(y_test, y_pred_sigmoid, cm_title_sigmoid)

הפלט של הקרנל SVM עם ליבת Sigmoid נראה כך:

 precision recall f1-score support 0 0.67 0.71 0.69 148 1 0.64 0.59 0.61 127 accuracy 0.65 275 macro avg 0.65 0.65 0.65 275
weighted avg 0.65 0.65 0.65 275

השוואה בין ביצועי ליבה לא לינאריים

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

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

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

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

הולך רחוק יותר - פרויקט מקצה לקצה ביד

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

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

באמצעות Keras, API ללמידה עמוקה שנבנה על גבי Tensorflow, נתנסה בארכיטקטורות, נבנה אנסמבל של מודלים מוערמים ונאמן מטא-לומד רשת עצבית (מודל רמה 1) כדי להבין את התמחור של בית.

למידה עמוקה היא מדהימה - אבל לפני שניגשים אליה, מומלץ לנסות לפתור את הבעיה גם בטכניקות פשוטות יותר, כמו עם למידה רדודה אלגוריתמים. ביצועי הבסיס שלנו יתבססו על א רגרסיה אקראית של יער אַלגוֹרִיתְם. בנוסף - נחקור יצירת אנסמבלים של מודלים באמצעות Scikit-Learn באמצעות טכניקות כגון שקית ו הצבעה.

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

סיכום

במאמר זה ערכנו סיכום מהיר על SVMs, למדנו על טריק הליבה ויישמנו טעמים שונים של SVMs לא ליניאריים.

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

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

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